/* Functions to handle multilingual characters.
Copyright (C) 1992, 1995 Free Software Foundation, Inc.
Copyright (C) 1995 Sun Microsystems, Inc.
- Copyright (C) 1999,2000 MORIOKA Tomohiko
+ Copyright (C) 1999,2000,2001,2002 MORIOKA Tomohiko
This file is part of XEmacs.
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-/* Synched up with: FSF 20.3. Not in FSF. */
-
/* Rewritten by Ben Wing <ben@xemacs.org>. */
+/* Rewritten by MORIOKA Tomohiko <tomo@m17n.org> for XEmacs UTF-2000. */
+
#include <config.h>
+#ifdef UTF2000
+#include <limits.h>
+#endif
#include "lisp.h"
#include "buffer.h"
Lisp_Object Vcharset_latin_iso8859_9;
Lisp_Object Vcharset_japanese_jisx0208_1978;
Lisp_Object Vcharset_chinese_gb2312;
+Lisp_Object Vcharset_chinese_gb12345;
Lisp_Object Vcharset_japanese_jisx0208;
Lisp_Object Vcharset_japanese_jisx0208_1990;
Lisp_Object Vcharset_korean_ksc5601;
#ifdef UTF2000
Lisp_Object Vcharset_ucs;
Lisp_Object Vcharset_ucs_bmp;
+Lisp_Object Vcharset_ucs_smp;
+Lisp_Object Vcharset_ucs_sip;
+Lisp_Object Vcharset_ucs_cns;
+Lisp_Object Vcharset_ucs_jis;
+Lisp_Object Vcharset_ucs_ks;
+Lisp_Object Vcharset_ucs_big5;
Lisp_Object Vcharset_latin_viscii;
Lisp_Object Vcharset_latin_tcvn5712;
Lisp_Object Vcharset_latin_viscii_lower;
Lisp_Object Vcharset_latin_viscii_upper;
+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_4;
+Lisp_Object Vcharset_ideograph_hanziku_5;
+Lisp_Object Vcharset_ideograph_hanziku_6;
+Lisp_Object Vcharset_ideograph_hanziku_7;
+Lisp_Object Vcharset_ideograph_hanziku_8;
+Lisp_Object Vcharset_ideograph_hanziku_9;
+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;
+Lisp_Object Vcharset_ideograph_gt_pj_2;
+Lisp_Object Vcharset_ideograph_gt_pj_3;
+Lisp_Object Vcharset_ideograph_gt_pj_4;
+Lisp_Object Vcharset_ideograph_gt_pj_5;
+Lisp_Object Vcharset_ideograph_gt_pj_6;
+Lisp_Object Vcharset_ideograph_gt_pj_7;
+Lisp_Object Vcharset_ideograph_gt_pj_8;
+Lisp_Object Vcharset_ideograph_gt_pj_9;
+Lisp_Object Vcharset_ideograph_gt_pj_10;
+Lisp_Object Vcharset_ideograph_gt_pj_11;
+Lisp_Object Vcharset_ideograph_daikanwa_2;
Lisp_Object Vcharset_ideograph_daikanwa;
-Lisp_Object Vcharset_mojikyo;
-Lisp_Object Vcharset_mojikyo_pj_1;
-Lisp_Object Vcharset_mojikyo_pj_2;
-Lisp_Object Vcharset_mojikyo_pj_3;
-Lisp_Object Vcharset_mojikyo_pj_4;
-Lisp_Object Vcharset_mojikyo_pj_5;
-Lisp_Object Vcharset_mojikyo_pj_6;
-Lisp_Object Vcharset_mojikyo_pj_7;
-Lisp_Object Vcharset_mojikyo_pj_8;
-Lisp_Object Vcharset_mojikyo_pj_9;
-Lisp_Object Vcharset_mojikyo_pj_10;
-Lisp_Object Vcharset_mojikyo_pj_11;
-Lisp_Object Vcharset_mojikyo_pj_12;
-Lisp_Object Vcharset_mojikyo_pj_13;
-Lisp_Object Vcharset_mojikyo_pj_14;
-Lisp_Object Vcharset_mojikyo_pj_15;
-Lisp_Object Vcharset_mojikyo_pj_16;
-Lisp_Object Vcharset_mojikyo_pj_17;
-Lisp_Object Vcharset_mojikyo_pj_18;
-Lisp_Object Vcharset_mojikyo_pj_19;
-Lisp_Object Vcharset_mojikyo_pj_20;
-Lisp_Object Vcharset_mojikyo_pj_21;
Lisp_Object Vcharset_ethiopic_ucs;
#endif
Lisp_Object Vcharset_chinese_big5_1;
#ifdef UTF2000
-static Lisp_Object
-mark_byte_table (Lisp_Object obj)
-{
- Lisp_Byte_Table *cte = XBYTE_TABLE (obj);
- int i;
-
- for (i = 0; i < 256; i++)
- {
- mark_object (cte->property[i]);
- }
- return Qnil;
-}
-
-static int
-byte_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
-{
- Lisp_Byte_Table *cte1 = XBYTE_TABLE (obj1);
- Lisp_Byte_Table *cte2 = XBYTE_TABLE (obj2);
- int i;
-
- for (i = 0; i < 256; i++)
- if (BYTE_TABLE_P (cte1->property[i]))
- {
- if (BYTE_TABLE_P (cte2->property[i]))
- {
- if (!byte_table_equal (cte1->property[i],
- cte2->property[i], depth + 1))
- return 0;
- }
- else
- return 0;
- }
- else
- if (!internal_equal (cte1->property[i], cte2->property[i], depth + 1))
- return 0;
- return 1;
-}
-
-static unsigned long
-byte_table_hash (Lisp_Object obj, int depth)
-{
- Lisp_Byte_Table *cte = XBYTE_TABLE (obj);
-
- return internal_array_hash (cte->property, 256, depth);
-}
-
-static const struct lrecord_description byte_table_description[] = {
- { XD_LISP_OBJECT_ARRAY, offsetof(Lisp_Byte_Table, property), 256 },
- { XD_END }
-};
-
-DEFINE_LRECORD_IMPLEMENTATION ("byte-table", byte_table,
- mark_byte_table,
- internal_object_printer,
- 0, byte_table_equal,
- byte_table_hash,
- byte_table_description,
- Lisp_Byte_Table);
-
-static Lisp_Object
-make_byte_table (Lisp_Object initval, int older)
-{
- Lisp_Object obj;
- int i;
- Lisp_Byte_Table *cte;
-
- if (older)
- cte = alloc_older_lcrecord_type (Lisp_Byte_Table, &lrecord_byte_table);
- else
- cte = alloc_lcrecord_type (Lisp_Byte_Table, &lrecord_byte_table);
-
- for (i = 0; i < 256; i++)
- cte->property[i] = initval;
-
- XSETBYTE_TABLE (obj, cte);
- return obj;
-}
-
-static Lisp_Object
-copy_byte_table (Lisp_Object entry)
+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)
{
- Lisp_Byte_Table *cte = XBYTE_TABLE (entry);
- Lisp_Object obj;
int i;
- Lisp_Byte_Table *ctenew
- = alloc_lcrecord_type (Lisp_Byte_Table, &lrecord_byte_table);
-
- for (i = 0; i < 256; i++)
- {
- Lisp_Object new = cte->property[i];
- if (BYTE_TABLE_P (new))
- ctenew->property[i] = copy_byte_table (new);
- else
- ctenew->property[i] = new;
- }
-
- XSETBYTE_TABLE (obj, ctenew);
- return obj;
-}
-
-
-static Lisp_Object
-mark_char_id_table (Lisp_Object obj)
-{
- Lisp_Char_ID_Table *cte = XCHAR_ID_TABLE (obj);
- return cte->table;
-}
-
-static int
-char_id_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
-{
- Lisp_Char_ID_Table *cte1 = XCHAR_ID_TABLE (obj1);
- Lisp_Char_ID_Table *cte2 = XCHAR_ID_TABLE (obj2);
-
- return byte_table_equal (cte1->table, cte2->table, depth + 1);
-}
-
-static unsigned long
-char_id_table_hash (Lisp_Object obj, int depth)
-{
- Lisp_Char_ID_Table *cte = XCHAR_ID_TABLE (obj);
-
- return char_id_table_hash (cte->table, depth + 1);
-}
-
-static const struct lrecord_description char_id_table_description[] = {
- { XD_LISP_OBJECT, offsetof(Lisp_Char_ID_Table, table) },
- { XD_END }
-};
-
-DEFINE_LRECORD_IMPLEMENTATION ("char-id-table", char_id_table,
- mark_char_id_table,
- internal_object_printer,
- 0, char_id_table_equal,
- char_id_table_hash,
- char_id_table_description,
- Lisp_Char_ID_Table);
-
-static Lisp_Object
-make_char_id_table (Lisp_Object initval, int older)
-{
- Lisp_Object obj;
- Lisp_Char_ID_Table *cte;
-
- if (older)
- cte = alloc_older_lcrecord_type (Lisp_Char_ID_Table,
- &lrecord_char_id_table);
- else
- cte = alloc_lcrecord_type (Lisp_Char_ID_Table, &lrecord_char_id_table);
-
- cte->table = make_byte_table (initval, older);
-
- XSETCHAR_ID_TABLE (obj, cte);
- return obj;
-}
-
-/* not used */
-#if 0
-static Lisp_Object
-copy_char_id_table (Lisp_Object entry)
-{
- Lisp_Char_ID_Table *cte = XCHAR_ID_TABLE (entry);
- Lisp_Object obj;
- Lisp_Char_ID_Table *ctenew
- = alloc_lcrecord_type (Lisp_Char_ID_Table, &lrecord_char_id_table);
-
- ctenew->table = copy_byte_table (cte->table);
- XSETCHAR_ID_TABLE (obj, ctenew);
- return obj;
-}
-#endif
-
-
-Lisp_Object
-get_char_id_table (Emchar ch, Lisp_Object table)
-{
- unsigned int code = ch;
- Lisp_Byte_Table* cpt
- = XBYTE_TABLE (XCHAR_ID_TABLE (table)->table);
- Lisp_Object ret = cpt->property [(unsigned char)(code >> 24)];
-
- if (BYTE_TABLE_P (ret))
- cpt = XBYTE_TABLE (ret);
- else
- return ret;
-
- ret = cpt->property [(unsigned char) (code >> 16)];
- if (BYTE_TABLE_P (ret))
- cpt = XBYTE_TABLE (ret);
- else
- return ret;
-
- ret = cpt->property [(unsigned char) (code >> 8)];
- if (BYTE_TABLE_P (ret))
- cpt = XBYTE_TABLE (ret);
- else
- return ret;
-
- return cpt->property [(unsigned char) code];
-}
-
-void put_char_id_table (Emchar ch, Lisp_Object value, Lisp_Object table);
-void
-put_char_id_table (Emchar ch, Lisp_Object value, Lisp_Object table)
-{
- unsigned int code = ch;
- Lisp_Byte_Table* cpt1 = XBYTE_TABLE (XCHAR_ID_TABLE (table)->table);
- Lisp_Object ret = cpt1->property[(unsigned char)(code >> 24)];
-
- if (BYTE_TABLE_P (ret))
- {
- Lisp_Byte_Table* cpt2 = XBYTE_TABLE (ret);
-
- ret = cpt2->property[(unsigned char)(code >> 16)];
- if (BYTE_TABLE_P (ret))
- {
- Lisp_Byte_Table* cpt3 = XBYTE_TABLE (ret);
-
- ret = cpt3->property[(unsigned char)(code >> 8)];
- if (BYTE_TABLE_P (ret))
- {
- Lisp_Byte_Table* cpt4 = XBYTE_TABLE (ret);
-
- cpt4->property[(unsigned char)code] = value;
- }
- else if (!EQ (ret, value))
- {
- Lisp_Object cpt4
- = make_byte_table (ret, OLDER_RECORD_P (table));
-
- XBYTE_TABLE(cpt4)->property[(unsigned char)code] = value;
- cpt3->property[(unsigned char)(code >> 8)] = cpt4;
- }
- }
- else if (!EQ (ret, value))
- {
- int older = OLDER_RECORD_P (table);
- Lisp_Object cpt3 = make_byte_table (ret, older);
- Lisp_Object cpt4 = make_byte_table (ret, older);
-
- XBYTE_TABLE(cpt4)->property[(unsigned char)code] = value;
- XBYTE_TABLE(cpt3)->property[(unsigned char)(code >> 8)]
- = cpt4;
- cpt2->property[(unsigned char)(code >> 16)] = cpt3;
- }
- }
- else if (!EQ (ret, value))
- {
- int older = OLDER_RECORD_P (table);
- Lisp_Object cpt2 = make_byte_table (ret, older);
- Lisp_Object cpt3 = make_byte_table (ret, older);
- Lisp_Object cpt4 = make_byte_table (ret, older);
-
- XBYTE_TABLE(cpt4)->property[(unsigned char)code] = value;
- XBYTE_TABLE(cpt3)->property[(unsigned char)(code >> 8)] = cpt4;
- XBYTE_TABLE(cpt2)->property[(unsigned char)(code >> 16)] = cpt3;
- cpt1->property[(unsigned char)(code >> 24)] = cpt2;
- }
-}
-
-
-Lisp_Object Vcharacter_attribute_table;
-Lisp_Object Vcharacter_name_table;
-Lisp_Object Vcharacter_composition_table;
-Lisp_Object Vcharacter_variant_table;
-
-Lisp_Object Qname;
-Lisp_Object Q_decomposition;
-Lisp_Object Qucs;
-Lisp_Object Q_ucs;
-Lisp_Object Qcompat;
-Lisp_Object Qisolated;
-Lisp_Object Qinitial;
-Lisp_Object Qmedial;
-Lisp_Object Qfinal;
-Lisp_Object Qvertical;
-Lisp_Object QnoBreak;
-Lisp_Object Qfraction;
-Lisp_Object Qsuper;
-Lisp_Object Qsub;
-Lisp_Object Qcircle;
-Lisp_Object Qsquare;
-Lisp_Object Qwide;
-Lisp_Object Qnarrow;
-Lisp_Object Qsmall;
-Lisp_Object Qfont;
-
-Emchar to_char_id (Lisp_Object v, char* err_msg, Lisp_Object err_arg);
-
-Lisp_Object put_char_ccs_code_point (Lisp_Object character,
- Lisp_Object ccs, Lisp_Object value);
-Lisp_Object remove_char_ccs (Lisp_Object character, Lisp_Object ccs);
-
-Lisp_Object put_char_attribute (Lisp_Object character,
- Lisp_Object attribute, Lisp_Object value);
-Lisp_Object remove_char_attribute (Lisp_Object character,
- Lisp_Object attribute);
-
-
-Emchar
-to_char_id (Lisp_Object v, char* err_msg, Lisp_Object err_arg)
-{
- if (INTP (v))
- return XINT (v);
- if (CHARP (v))
- return XCHAR (v);
- else if (EQ (v, Qcompat))
+ if (XVECTOR_LENGTH (v) > ccs_len)
return -1;
- else if (EQ (v, Qisolated))
- return -2;
- else if (EQ (v, Qinitial))
- return -3;
- else if (EQ (v, Qmedial))
- return -4;
- else if (EQ (v, Qfinal))
- return -5;
- else if (EQ (v, Qvertical))
- return -6;
- else if (EQ (v, QnoBreak))
- return -7;
- else if (EQ (v, Qfraction))
- return -8;
- else if (EQ (v, Qsuper))
- return -9;
- else if (EQ (v, Qsub))
- return -10;
- else if (EQ (v, Qcircle))
- return -11;
- else if (EQ (v, Qsquare))
- return -12;
- else if (EQ (v, Qwide))
- return -13;
- else if (EQ (v, Qnarrow))
- return -14;
- else if (EQ (v, Qsmall))
- return -15;
- else if (EQ (v, Qfont))
- return -16;
- else
- signal_simple_error (err_msg, err_arg);
-}
-
-DEFUN ("get-composite-char", Fget_composite_char, 1, 1, 0, /*
-Return character corresponding with list.
-*/
- (list))
-{
- Lisp_Object table = Vcharacter_composition_table;
- Lisp_Object rest = list;
- while (CONSP (rest))
- {
- Lisp_Object v = Fcar (rest);
- Lisp_Object ret;
- Emchar c = to_char_id (v, "Invalid value for composition", list);
-
- ret = get_char_id_table (c, table);
-
- rest = Fcdr (rest);
- if (NILP (rest))
- {
- if (!CHAR_ID_TABLE_P (ret))
- return ret;
- else
- return Qt;
- }
- else if (!CONSP (rest))
- break;
- else if (CHAR_ID_TABLE_P (ret))
- table = ret;
- else
- signal_simple_error ("Invalid table is found with", list);
- }
- signal_simple_error ("Invalid value for composition", list);
-}
-
-DEFUN ("char-variants", Fchar_variants, 1, 1, 0, /*
-Return variants of CHARACTER.
-*/
- (character))
-{
- CHECK_CHAR (character);
- return Fcopy_list (get_char_id_table (XCHAR (character),
- Vcharacter_variant_table));
-}
-
-DEFUN ("char-attribute-alist", Fchar_attribute_alist, 1, 1, 0, /*
-Return the alist of attributes of CHARACTER.
-*/
- (character))
-{
- CHECK_CHAR (character);
- return Fcopy_alist (get_char_id_table (XCHAR (character),
- Vcharacter_attribute_table));
-}
-
-DEFUN ("get-char-attribute", Fget_char_attribute, 2, 2, 0, /*
-Return the value of CHARACTER's ATTRIBUTE.
-*/
- (character, attribute))
-{
- Lisp_Object ccs;
-
- CHECK_CHAR (character);
- if (!NILP (ccs = Ffind_charset (attribute)))
- {
- Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (ccs);
-
- if (CHAR_ID_TABLE_P (encoding_table))
- return get_char_id_table (XCHAR (character), encoding_table);
- else
- return Qnil;
- }
- else if (EQ (attribute, Qname))
- {
- return get_char_id_table (XCHAR (character), Vcharacter_name_table);
- }
- else
- {
- Lisp_Object ret
- = get_char_id_table (XCHAR (character), Vcharacter_attribute_table);
-
- if (EQ (ret, Qnil))
- return Qnil;
- else
- return Fcdr (Fassq (attribute, ret));
- }
-}
-
-DEFUN ("put-char-attribute", Fput_char_attribute, 3, 3, 0, /*
-Store CHARACTER's ATTRIBUTE with VALUE.
-*/
- (character, attribute, value))
-{
- Lisp_Object ccs;
-
- CHECK_CHAR (character);
- ccs = Ffind_charset (attribute);
- if (!NILP (ccs))
- {
- return put_char_ccs_code_point (character, ccs, value);
- }
- else if (EQ (attribute, Qname))
- {
- CHECK_STRING (value);
- put_char_id_table (XCHAR (character), value, Vcharacter_name_table);
- return value;
- }
- else if (EQ (attribute, Q_decomposition))
+ for (i = 0; i < XVECTOR_LENGTH (v); i++)
{
- if (!CONSP (value))
- signal_simple_error ("Invalid value for ->decomposition",
- value);
+ Lisp_Object c = XVECTOR_DATA(v)[i];
- if (CONSP (Fcdr (value)))
+ if (!NILP (c) && !CHARP (c))
{
- Lisp_Object rest = value;
- Lisp_Object table = Vcharacter_composition_table;
-
- while (CONSP (rest))
+ if (VECTORP (c))
{
- Lisp_Object v = Fcar (rest);
- Lisp_Object ntable;
- Emchar c
- = to_char_id (v, "Invalid value for ->decomposition", value);
-
- rest = Fcdr (rest);
- if (!CONSP (rest))
- {
- put_char_id_table (c, character, table);
- break;
- }
- else
- {
- ntable = get_char_id_table (c, table);
- if (!CHAR_ID_TABLE_P (ntable))
- {
- ntable
- = make_char_id_table (Qnil, OLDER_RECORD_P (table));
- put_char_id_table (c, ntable, table);
- }
- table = ntable;
- }
+ int ret = decoding_table_check_elements (c, dim - 1, ccs_len);
+ if (ret)
+ return ret;
}
+ else
+ return -2;
}
- else
- {
- Lisp_Object v = Fcar (value);
-
- if (INTP (v))
- {
- Emchar c = XINT (v);
- Lisp_Object ret
- = get_char_id_table (c, Vcharacter_variant_table);
-
- if (NILP (Fmemq (v, ret)))
- {
- put_char_id_table (c, Fcons (character, ret),
- Vcharacter_variant_table);
- }
- }
- }
- }
- else if (EQ (attribute, Q_ucs))
- {
- Lisp_Object ret;
- Emchar c;
-
- if (!INTP (value))
- signal_simple_error ("Invalid value for ->ucs", value);
-
- c = XINT (value);
-
- ret = get_char_id_table (c, Vcharacter_variant_table);
- if (NILP (Fmemq (character, ret)))
- {
- put_char_id_table (c, Fcons (character, ret),
- Vcharacter_variant_table);
- }
- }
- return put_char_attribute (character, attribute, value);
-}
-
-DEFUN ("remove-char-attribute", Fremove_char_attribute, 2, 2, 0, /*
-Remove CHARACTER's ATTRIBUTE.
-*/
- (character, attribute))
-{
- Lisp_Object ccs;
-
- CHECK_CHAR (character);
- ccs = Ffind_charset (attribute);
- if (!NILP (ccs))
- {
- return remove_char_ccs (character, ccs);
- }
- return remove_char_attribute (character, attribute);
-}
-
-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))
-
-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;
+ return 0;
}
Lisp_Object
put_char_ccs_code_point (Lisp_Object character,
Lisp_Object ccs, Lisp_Object value)
{
- Lisp_Object encoding_table;
-
if (!EQ (XCHARSET_NAME (ccs), Qucs)
+ || !INTP (value)
|| (XCHAR (character) != XINT (value)))
{
- Lisp_Object cpos, rest;
Lisp_Object v = XCHARSET_DECODING_TABLE (ccs);
- Lisp_Object nv;
- int i = -1;
- 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))
{ /* obsolete representation: value must be a list of bytes */
Lisp_Object ret = Fcar (value);
+ Lisp_Object rest;
if (!INTP (ret))
signal_simple_error ("Invalid value for coded-charset", value);
}
else if (INTP (value))
{
+ code_point = XINT (value);
if (XCHARSET_GRAPHIC (ccs) == 1)
- value = make_int (XINT (value) & 0x7F7F7F7F);
- }
- else
- signal_simple_error ("Invalid value for coded-charset", value);
-
- cpos = Fget_char_attribute (character, ccs);
- if (VECTORP (v))
- {
- if (!NILP (cpos))
{
- decoding_table_remove_char (v, dim, byte_offset, XINT (cpos));
+ code_point &= 0x7F7F7F7F;
+ value = make_int (code_point);
}
}
else
- {
- XCHARSET_DECODING_TABLE (ccs) = v
- = make_older_vector (ccs_len, Qnil);
- }
+ signal_simple_error ("Invalid value for coded-charset", value);
- code_point = XINT (value);
- i = -1;
- while (dim > 0)
+ if (VECTORP (v))
{
- dim--;
- i = ((code_point >> (8 * dim)) & 255) - byte_offset;
- nv = XVECTOR_DATA(v)[i];
- if (dim > 0)
+ Lisp_Object cpos = Fget_char_attribute (character, ccs, Qnil);
+ if (INTP (cpos))
{
- if (!VECTORP (nv))
- nv = (XVECTOR_DATA(v)[i]
- = make_older_vector (ccs_len, Qnil));
- v = nv;
+ decoding_table_remove_char (ccs, XINT (cpos));
}
- else
- break;
}
- XVECTOR_DATA(v)[i] = character;
- }
- if (NILP (encoding_table = XCHARSET_ENCODING_TABLE (ccs)))
- {
- XCHARSET_ENCODING_TABLE (ccs) = encoding_table
- = make_char_id_table (Qnil, -1);
+ decoding_table_put_char (ccs, code_point, character);
}
- put_char_id_table (XCHAR (character), value, encoding_table);
- return Qt;
+ return value;
}
Lisp_Object
if (VECTORP (decoding_table))
{
- Lisp_Object cpos = Fget_char_attribute (character, ccs);
+ Lisp_Object cpos = Fget_char_attribute (character, ccs, Qnil);
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_ID_TABLE_P (encoding_table))
+ if (CHAR_TABLEP (encoding_table))
{
- put_char_id_table (XCHAR (character), Qnil, encoding_table);
+ put_char_id_table (XCHAR_TABLE(encoding_table), character, Qunbound);
}
return Qt;
}
-Lisp_Object
-put_char_attribute (Lisp_Object character, Lisp_Object attribute,
- Lisp_Object value)
-{
- Emchar char_id = XCHAR (character);
- Lisp_Object ret = get_char_id_table (char_id, Vcharacter_attribute_table);
- Lisp_Object cell;
-
- cell = Fassq (attribute, ret);
-
- if (NILP (cell))
- {
- ret = Fcons (Fcons (attribute, value), ret);
- }
- else if (!EQ (Fcdr (cell), value))
- {
- Fsetcdr (cell, value);
- }
- put_char_id_table (char_id, ret, Vcharacter_attribute_table);
- return ret;
-}
-
-Lisp_Object
-remove_char_attribute (Lisp_Object character, Lisp_Object attribute)
-{
- Emchar char_id = XCHAR (character);
- Lisp_Object alist = get_char_id_table (char_id, Vcharacter_attribute_table);
-
- if (EQ (attribute, Fcar (Fcar (alist))))
- {
- alist = Fcdr (alist);
- }
- else
- {
- Lisp_Object pr = alist;
- Lisp_Object r = Fcdr (alist);
-
- while (!NILP (r))
- {
- if (EQ (attribute, Fcar (Fcar (r))))
- {
- XCDR (pr) = Fcdr (r);
- break;
- }
- pr = r;
- r = Fcdr (r);
- }
- }
- put_char_id_table (char_id, alist, Vcharacter_attribute_table);
- return alist;
-}
-
-EXFUN (Fmake_char, 3);
-EXFUN (Fdecode_char, 2);
-
-DEFUN ("define-char", Fdefine_char, 1, 1, 0, /*
-Store character's ATTRIBUTES.
-*/
- (attributes))
-{
- Lisp_Object rest = attributes;
- Lisp_Object code = Fcdr (Fassq (Qucs, attributes));
- Lisp_Object character;
-
- if (NILP (code))
- {
- while (CONSP (rest))
- {
- Lisp_Object cell = Fcar (rest);
- Lisp_Object ccs;
-
- if (!LISTP (cell))
- signal_simple_error ("Invalid argument", attributes);
- if (!NILP (ccs = Ffind_charset (Fcar (cell)))
- && ((XCHARSET_FINAL (ccs) != 0) ||
- (XCHARSET_UCS_MAX (ccs) > 0)) )
- {
- cell = Fcdr (cell);
- if (CONSP (cell))
- character = Fmake_char (ccs, Fcar (cell), Fcar (Fcdr (cell)));
- else
- character = Fdecode_char (ccs, cell);
- goto setup_attributes;
- }
- rest = Fcdr (rest);
- }
- if (!NILP (code = Fcdr (Fassq (Q_ucs, attributes))))
- {
- if (!INTP (code))
- signal_simple_error ("Invalid argument", attributes);
- else
- character = make_char (XINT (code) + 0x100000);
- goto setup_attributes;
- }
- return Qnil;
- }
- else if (!INTP (code))
- signal_simple_error ("Invalid argument", attributes);
- else
- character = make_char (XINT (code));
-
- setup_attributes:
- rest = attributes;
- while (CONSP (rest))
- {
- Lisp_Object cell = Fcar (rest);
-
- if (!LISTP (cell))
- signal_simple_error ("Invalid argument", attributes);
- Fput_char_attribute (character, Fcar (cell), Fcdr (cell));
- rest = Fcdr (rest);
- }
- return
- get_char_id_table (XCHAR (character), Vcharacter_attribute_table);
-}
-
-Lisp_Object Vutf_2000_version;
#endif
#ifndef UTF2000
Lisp_Object Qreverse_direction_charset;
Lisp_Object Qleading_byte;
Lisp_Object Qshort_name, Qlong_name;
+#ifdef UTF2000
+Lisp_Object Qmin_code, Qmax_code, Qcode_offset;
+Lisp_Object Qmother, Qconversion, Q94x60, Q94x94x60, Qbig5_1, Qbig5_2;
+#endif
Lisp_Object Qascii,
Qcontrol_1,
Qlatin_iso8859_9,
Qjapanese_jisx0208_1978,
Qchinese_gb2312,
+ Qchinese_gb12345,
Qjapanese_jisx0208,
Qjapanese_jisx0208_1990,
Qkorean_ksc5601,
Qchinese_cns11643_1,
Qchinese_cns11643_2,
#ifdef UTF2000
+ Qucs,
Qucs_bmp,
+ Qucs_smp,
+ Qucs_sip,
+ Qucs_cns,
+ Qucs_jis,
+ Qucs_ks,
+ Qucs_big5,
Qlatin_viscii,
Qlatin_tcvn5712,
Qlatin_viscii_lower,
Qlatin_viscii_upper,
Qvietnamese_viscii_lower,
Qvietnamese_viscii_upper,
+ Qchinese_big5,
+ /* Qchinese_big5_cdp, */
+ Qideograph_hanziku_1,
+ Qideograph_hanziku_2,
+ Qideograph_hanziku_3,
+ Qideograph_hanziku_4,
+ Qideograph_hanziku_5,
+ Qideograph_hanziku_6,
+ Qideograph_hanziku_7,
+ Qideograph_hanziku_8,
+ Qideograph_hanziku_9,
+ Qideograph_hanziku_10,
+ Qideograph_hanziku_11,
+ Qideograph_hanziku_12,
+ Qchina3_jef,
+ Qideograph_cbeta,
+ Qideograph_daikanwa_2,
Qideograph_daikanwa,
- Qmojikyo,
- Qmojikyo_pj_1,
- Qmojikyo_pj_2,
- Qmojikyo_pj_3,
- Qmojikyo_pj_4,
- Qmojikyo_pj_5,
- Qmojikyo_pj_6,
- Qmojikyo_pj_7,
- Qmojikyo_pj_8,
- Qmojikyo_pj_9,
- Qmojikyo_pj_10,
- Qmojikyo_pj_11,
- Qmojikyo_pj_12,
- Qmojikyo_pj_13,
- Qmojikyo_pj_14,
- Qmojikyo_pj_15,
- Qmojikyo_pj_16,
- Qmojikyo_pj_17,
- Qmojikyo_pj_18,
- Qmojikyo_pj_19,
- Qmojikyo_pj_20,
- Qmojikyo_pj_21,
+ Qideograph_gt,
+ Qideograph_gt_pj_1,
+ Qideograph_gt_pj_2,
+ Qideograph_gt_pj_3,
+ Qideograph_gt_pj_4,
+ Qideograph_gt_pj_5,
+ Qideograph_gt_pj_6,
+ Qideograph_gt_pj_7,
+ Qideograph_gt_pj_8,
+ Qideograph_gt_pj_9,
+ Qideograph_gt_pj_10,
+ Qideograph_gt_pj_11,
Qethiopic_ucs,
#endif
Qchinese_big5_1,
/* Basic string functions */
/************************************************************************/
-/* Copy the character pointed to by PTR into STR, assuming it's
- non-ASCII. Do not call this directly. Use the macro
- charptr_copy_char() instead. */
+/* Copy the character pointed to by SRC into DST. Do not call this
+ directly. Use the macro charptr_copy_char() instead.
+ Return the number of bytes copied. */
Bytecount
-non_ascii_charptr_copy_char (const Bufbyte *ptr, Bufbyte *str)
+non_ascii_charptr_copy_char (const Bufbyte *src, Bufbyte *dst)
{
- Bufbyte *strptr = str;
- *strptr = *ptr++;
- switch (REP_BYTES_BY_FIRST_BYTE (*strptr))
- {
- /* Notice fallthrough. */
-#ifdef UTF2000
- case 6: *++strptr = *ptr++;
- case 5: *++strptr = *ptr++;
-#endif
- case 4: *++strptr = *ptr++;
- case 3: *++strptr = *ptr++;
- case 2: *++strptr = *ptr;
- break;
- default:
- abort ();
- }
- return strptr + 1 - str;
+ unsigned int bytes = REP_BYTES_BY_FIRST_BYTE (*src);
+ unsigned int i;
+ for (i = bytes; i; i--, dst++, src++)
+ *dst = *src;
+ return bytes;
}
\f
{
Bufbyte str[MAX_EMCHAR_LEN];
Bufbyte *strptr = str;
+ unsigned int bytes;
str[0] = (Bufbyte) ch;
- switch (REP_BYTES_BY_FIRST_BYTE (ch))
+
+ for (bytes = REP_BYTES_BY_FIRST_BYTE (ch) - 1; bytes; bytes--)
{
- /* Notice fallthrough. */
-#ifdef UTF2000
- case 6:
- ch = Lstream_getc (stream);
- assert (ch >= 0);
- *++strptr = (Bufbyte) ch;
- case 5:
- ch = Lstream_getc (stream);
- assert (ch >= 0);
- *++strptr = (Bufbyte) ch;
-#endif
- case 4:
- ch = Lstream_getc (stream);
- assert (ch >= 0);
- *++strptr = (Bufbyte) ch;
- case 3:
- ch = Lstream_getc (stream);
- assert (ch >= 0);
- *++strptr = (Bufbyte) ch;
- case 2:
- ch = Lstream_getc (stream);
- assert (ch >= 0);
- *++strptr = (Bufbyte) ch;
- break;
- default:
- abort ();
+ int c = Lstream_getc (stream);
+ bufpos_checking_assert (c >= 0);
+ *++strptr = (Bufbyte) c;
}
return charptr_emchar (str);
}
mark_object (cs->registry);
mark_object (cs->ccl_program);
#ifdef UTF2000
- /* mark_object (cs->encoding_table); */
- /* mark_object (cs->decoding_table); */
+ mark_object (cs->decoding_table);
+ mark_object (cs->mother);
#endif
return cs->name;
}
{ XD_LISP_OBJECT, offsetof (Lisp_Charset, ccl_program) },
#ifdef UTF2000
{ XD_LISP_OBJECT, offsetof (Lisp_Charset, decoding_table) },
- { XD_LISP_OBJECT, offsetof (Lisp_Charset, encoding_table) },
+ { XD_LISP_OBJECT, offsetof (Lisp_Charset, mother) },
#endif
{ XD_END }
};
mark_charset, print_charset, 0, 0, 0,
charset_description,
Lisp_Charset);
-/* Make a new charset. */
+/* Make a new charset. */
+/* #### SJT Should generic properties be allowed? */
static Lisp_Object
make_charset (Charset_ID id, Lisp_Object name,
unsigned short chars, unsigned char dimension,
Lisp_Object long_name, Lisp_Object doc,
Lisp_Object reg,
Lisp_Object decoding_table,
- Emchar ucs_min, Emchar ucs_max,
- Emchar code_offset, unsigned char byte_offset)
+ Emchar min_code, Emchar max_code,
+ Emchar code_offset, unsigned char byte_offset,
+ Lisp_Object mother, unsigned char conversion)
{
- unsigned char type = 0;
Lisp_Object obj;
Lisp_Charset *cs = alloc_lcrecord_type (Lisp_Charset, &lrecord_charset);
CHARSET_CCL_PROGRAM (cs) = Qnil;
CHARSET_REVERSE_DIRECTION_CHARSET (cs) = Qnil;
#ifdef UTF2000
- CHARSET_DECODING_TABLE(cs) = Qnil;
- CHARSET_ENCODING_TABLE(cs) = Qnil;
- CHARSET_UCS_MIN(cs) = ucs_min;
- CHARSET_UCS_MAX(cs) = ucs_max;
- CHARSET_CODE_OFFSET(cs) = code_offset;
- CHARSET_BYTE_OFFSET(cs) = byte_offset;
-#endif
-
- switch (CHARSET_CHARS (cs))
- {
- case 94:
- switch (CHARSET_DIMENSION (cs))
- {
- case 1:
- type = CHARSET_TYPE_94;
- break;
- case 2:
- type = CHARSET_TYPE_94X94;
- break;
- }
- break;
- case 96:
- switch (CHARSET_DIMENSION (cs))
- {
- case 1:
- type = CHARSET_TYPE_96;
- break;
- case 2:
- type = CHARSET_TYPE_96X96;
- break;
- }
- break;
-#ifdef UTF2000
- case 128:
- switch (CHARSET_DIMENSION (cs))
- {
- case 1:
- type = CHARSET_TYPE_128;
- break;
- case 2:
- type = CHARSET_TYPE_128X128;
- break;
- }
- break;
- case 256:
- switch (CHARSET_DIMENSION (cs))
- {
- case 1:
- type = CHARSET_TYPE_256;
- break;
- case 2:
- type = CHARSET_TYPE_256X256;
- break;
- }
- break;
-#endif
- }
-#ifndef UTF2000
- CHARSET_TYPE (cs) = type;
+ CHARSET_DECODING_TABLE(cs) = Qunbound;
+ CHARSET_MIN_CODE (cs) = min_code;
+ CHARSET_MAX_CODE (cs) = max_code;
+ CHARSET_CODE_OFFSET (cs) = code_offset;
+ CHARSET_BYTE_OFFSET (cs) = byte_offset;
+ CHARSET_MOTHER (cs) = mother;
+ CHARSET_CONVERSION (cs) = conversion;
#endif
#ifndef UTF2000
/* some charsets do not have final characters. This includes
ASCII, Control-1, Composite, and the two faux private
charsets. */
+ unsigned char iso2022_type
+ = (dimension == 1 ? 0 : 2) + (chars == 94 ? 0 : 1);
#if UTF2000
if (code_offset == 0)
{
- assert (NILP (chlook->charset_by_attributes[type][final]));
- chlook->charset_by_attributes[type][final] = obj;
+ assert (NILP (chlook->charset_by_attributes[iso2022_type][final]));
+ chlook->charset_by_attributes[iso2022_type][final] = obj;
}
#else
- assert (NILP (chlook->charset_by_attributes[type][final][direction]));
- chlook->charset_by_attributes[type][final][direction] = obj;
+ assert (NILP
+ (chlook->charset_by_attributes[iso2022_type][final][direction]));
+ chlook->charset_by_attributes[iso2022_type][final][direction] = obj;
#endif
}
}
#ifdef UTF2000
+/* Number of Big5 characters which have the same code in 1st byte. */
+
+#define BIG5_SAME_ROW (0xFF - 0xA1 + 0x7F - 0x40)
+
Emchar
-make_builtin_char (Lisp_Object charset, int c1, int c2)
+decode_defined_char (Lisp_Object ccs, int code_point)
{
- if (XCHARSET_UCS_MAX (charset))
+ int dim = XCHARSET_DIMENSION (ccs);
+ Lisp_Object decoding_table = XCHARSET_DECODING_TABLE (ccs);
+ Emchar char_id = -1;
+ Lisp_Object mother;
+
+ while (dim > 0)
{
- Emchar code
- = (XCHARSET_DIMENSION (charset) == 1
- ?
- c1 - XCHARSET_BYTE_OFFSET (charset)
- :
- (c1 - XCHARSET_BYTE_OFFSET (charset)) * XCHARSET_CHARS (charset)
- + c2 - XCHARSET_BYTE_OFFSET (charset))
- - XCHARSET_CODE_OFFSET (charset) + XCHARSET_UCS_MIN (charset);
- if ((code < XCHARSET_UCS_MIN (charset))
- || (XCHARSET_UCS_MAX (charset) < code))
- signal_simple_error ("Arguments makes invalid character",
- make_char (code));
- return code;
+ dim--;
+ decoding_table
+ = get_ccs_octet_table (decoding_table, ccs,
+ (code_point >> (dim * 8)) & 255);
}
- else if (XCHARSET_DIMENSION (charset) == 1)
+ if (CHARP (decoding_table))
+ return XCHAR (decoding_table);
+#ifdef HAVE_DATABASE
+ if (EQ (decoding_table, Qunloaded) ||
+ EQ (decoding_table, Qunbound) ||
+ NILP (decoding_table) )
{
- switch (XCHARSET_CHARS (charset))
- {
- case 94:
- return MIN_CHAR_94
- + (XCHARSET_FINAL (charset) - '0') * 94 + (c1 - 33);
- case 96:
- return MIN_CHAR_96
- + (XCHARSET_FINAL (charset) - '0') * 96 + (c1 - 32);
- default:
- abort ();
- }
+ char_id = load_char_decoding_entry_maybe (ccs, code_point);
}
- else
+#endif
+ if (char_id >= 0)
+ return char_id;
+ else if ( CHARSETP (mother = XCHARSET_MOTHER (ccs)) )
{
- switch (XCHARSET_CHARS (charset))
+ if ( XCHARSET_CONVERSION (ccs) == CONVERSION_IDENTICAL )
+ {
+ if ( EQ (mother, Vcharset_ucs) )
+ return DECODE_CHAR (mother, code_point);
+ else
+ return decode_defined_char (mother, code_point);
+ }
+ else if ( XCHARSET_CONVERSION (ccs) == CONVERSION_BIG5_1 )
+ {
+ unsigned int I
+ = (((code_point >> 8) & 0x7F) - 33) * 94
+ + (( code_point & 0x7F) - 33);
+ unsigned char b1 = I / (0xFF - 0xA1 + 0x7F - 0x40) + 0xA1;
+ unsigned char b2 = I % (0xFF - 0xA1 + 0x7F - 0x40);
+
+ b2 += b2 < 0x3F ? 0x40 : 0x62;
+ return decode_defined_char (mother, (b1 << 8) | b2);
+ }
+ else if ( XCHARSET_CONVERSION (ccs) == CONVERSION_BIG5_2 )
{
- case 94:
- return MIN_CHAR_94x94
- + (XCHARSET_FINAL (charset) - '0') * 94 * 94
- + (c1 - 33) * 94 + (c2 - 33);
- case 96:
- return MIN_CHAR_96x96
- + (XCHARSET_FINAL (charset) - '0') * 96 * 96
- + (c1 - 32) * 96 + (c2 - 32);
- default:
- abort ();
+ unsigned int I
+ = (((code_point >> 8) & 0x7F) - 33) * 94
+ + (( code_point & 0x7F) - 33)
+ + BIG5_SAME_ROW * (0xC9 - 0xA1);
+ unsigned char b1 = I / (0xFF - 0xA1 + 0x7F - 0x40) + 0xA1;
+ unsigned char b2 = I % (0xFF - 0xA1 + 0x7F - 0x40);
+
+ b2 += b2 < 0x3F ? 0x40 : 0x62;
+ return decode_defined_char (mother, (b1 << 8) | b2);
}
}
+ return -1;
}
-int
-range_charset_code_point (Lisp_Object charset, Emchar ch)
+Emchar
+decode_builtin_char (Lisp_Object charset, int code_point)
{
- int d;
+ Lisp_Object mother = XCHARSET_MOTHER (charset);
+ int final;
+
+ if ( CHARSETP (mother) && (XCHARSET_MAX_CODE (charset) > 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 )
+ {
+ int plane = code_point >> 16;
+ int row = (code_point >> 8) & 255;
+ int cell = code_point & 255;
- if ((XCHARSET_UCS_MIN (charset) <= ch)
- && (ch <= XCHARSET_UCS_MAX (charset)))
+ 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;
+ }
+ else if ( XCHARSET_CONVERSION (charset) == CONVERSION_BIG5_1 )
+ {
+ unsigned int I
+ = (((code_point >> 8) & 0x7F) - 33) * 94
+ + (( code_point & 0x7F) - 33);
+ unsigned char b1 = I / (0xFF - 0xA1 + 0x7F - 0x40) + 0xA1;
+ unsigned char b2 = I % (0xFF - 0xA1 + 0x7F - 0x40);
+
+ b2 += b2 < 0x3F ? 0x40 : 0x62;
+ code = (b1 << 8) | b2;
+ }
+ else if ( XCHARSET_CONVERSION (charset) == CONVERSION_BIG5_2 )
+ {
+ unsigned int I
+ = (((code_point >> 8) & 0x7F) - 33) * 94
+ + (( code_point & 0x7F) - 33)
+ + BIG5_SAME_ROW * (0xC9 - 0xA1);
+ unsigned char b1 = I / (0xFF - 0xA1 + 0x7F - 0x40) + 0xA1;
+ unsigned char b2 = I % (0xFF - 0xA1 + 0x7F - 0x40);
+
+ b2 += b2 < 0x3F ? 0x40 : 0x62;
+ code = (b1 << 8) | b2;
+ }
+ return
+ decode_builtin_char (mother, code + XCHARSET_CODE_OFFSET(charset));
+ }
+#if 0
+ else if (EQ (charset, Vcharset_chinese_big5))
{
- d = ch - XCHARSET_UCS_MIN (charset) + XCHARSET_CODE_OFFSET (charset);
-
- if (XCHARSET_CHARS (charset) == 256)
- return d;
- else if (XCHARSET_DIMENSION (charset) == 1)
- return d + XCHARSET_BYTE_OFFSET (charset);
- else if (XCHARSET_DIMENSION (charset) == 2)
- return
- ((d / XCHARSET_CHARS (charset)
- + XCHARSET_BYTE_OFFSET (charset)) << 8)
- | (d % XCHARSET_CHARS (charset) + XCHARSET_BYTE_OFFSET (charset));
- else if (XCHARSET_DIMENSION (charset) == 3)
- return
- ((d / (XCHARSET_CHARS (charset) * XCHARSET_CHARS (charset))
- + XCHARSET_BYTE_OFFSET (charset)) << 16)
- | ((d / XCHARSET_CHARS (charset)
- % XCHARSET_CHARS (charset)
- + XCHARSET_BYTE_OFFSET (charset)) << 8)
- | (d % XCHARSET_CHARS (charset) + XCHARSET_BYTE_OFFSET (charset));
- else /* if (XCHARSET_DIMENSION (charset) == 4) */
- return
- ((d / (XCHARSET_CHARS (charset)
- * XCHARSET_CHARS (charset) * XCHARSET_CHARS (charset))
- + XCHARSET_BYTE_OFFSET (charset)) << 24)
- | ((d / (XCHARSET_CHARS (charset) * XCHARSET_CHARS (charset))
- % XCHARSET_CHARS (charset)
- + XCHARSET_BYTE_OFFSET (charset)) << 16)
- | ((d / XCHARSET_CHARS (charset) % XCHARSET_CHARS (charset)
- + XCHARSET_BYTE_OFFSET (charset)) << 8)
- | (d % XCHARSET_CHARS (charset) + XCHARSET_BYTE_OFFSET (charset));
+ 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)) ) )
+ {
+ I = (c1 - 0xA1) * BIG5_SAME_ROW
+ + c2 - (c2 < 0x7F ? 0x40 : 0x62);
+
+ if (c1 < 0xC9)
+ {
+ charset = Vcharset_chinese_big5_1;
+ }
+ else
+ {
+ charset = Vcharset_chinese_big5_2;
+ I -= (BIG5_SAME_ROW) * (0xC9 - 0xA1);
+ }
+ code_point = ((I / 94 + 33) << 8) | (I % 94 + 33);
+ }
}
- else if (XCHARSET_CODE_OFFSET (charset) == 0)
+#endif
+ if ((final = XCHARSET_FINAL (charset)) >= '0')
{
if (XCHARSET_DIMENSION (charset) == 1)
{
- if (XCHARSET_CHARS (charset) == 94)
+ switch (XCHARSET_CHARS (charset))
{
- if (((d = ch - (MIN_CHAR_94
- + (XCHARSET_FINAL (charset) - '0') * 94)) >= 0)
- && (d < 94))
- return d + 33;
+ case 94:
+ return MIN_CHAR_94
+ + (final - '0') * 94 + ((code_point & 0x7F) - 33);
+ case 96:
+ return MIN_CHAR_96
+ + (final - '0') * 96 + ((code_point & 0x7F) - 32);
+ default:
+ abort ();
+ return -1;
}
- else if (XCHARSET_CHARS (charset) == 96)
+ }
+ else
+ {
+ switch (XCHARSET_CHARS (charset))
{
- if (((d = ch - (MIN_CHAR_96
- + (XCHARSET_FINAL (charset) - '0') * 96)) >= 0)
- && (d < 96))
- return d + 32;
+ case 94:
+ return MIN_CHAR_94x94
+ + (final - '0') * 94 * 94
+ + (((code_point >> 8) & 0x7F) - 33) * 94
+ + ((code_point & 0x7F) - 33);
+ case 96:
+ return MIN_CHAR_96x96
+ + (final - '0') * 96 * 96
+ + (((code_point >> 8) & 0x7F) - 32) * 96
+ + ((code_point & 0x7F) - 32);
+ default:
+ abort ();
+ return -1;
}
- else
- return -1;
}
- else if (XCHARSET_DIMENSION (charset) == 2)
+ }
+ 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)
+{
+ Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (charset);
+ Lisp_Object ret;
+
+ if ( CHAR_TABLEP (encoding_table)
+ && INTP (ret = get_char_id_table (XCHAR_TABLE(encoding_table),
+ ch)) )
+ return XINT (ret);
+ else
+ {
+ Lisp_Object mother = XCHARSET_MOTHER (charset);
+ int min = XCHARSET_MIN_CODE (charset);
+ int max = XCHARSET_MAX_CODE (charset);
+ int code;
+
+ if ( CHARSETP (mother) )
+ code = charset_code_point (mother, ch);
+ else
+ code = ch;
+ if ( ((max == 0) && CHARSETP (mother)) ||
+ ((min <= code) && (code <= max)) )
{
- if (XCHARSET_CHARS (charset) == 94)
+ int d = code - XCHARSET_CODE_OFFSET (charset);
+
+ 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;
+
+ if (row < 30)
+ row += 16 + 32;
+ else
+ row += 18 + 32;
+ return (row << 8) | cell;
+ }
+ else if ( XCHARSET_CONVERSION (charset) == CONVERSION_BIG5_1 )
+ {
+ int B1 = d >> 8, B2 = d & 0xFF;
+ unsigned int I
+ = (B1 - 0xA1) * BIG5_SAME_ROW + B2
+ - (B2 < 0x7F ? 0x40 : 0x62);
+
+ if (B1 < 0xC9)
+ {
+ return ((I / 94 + 33) << 8) | (I % 94 + 33);
+ }
+ }
+ else if ( XCHARSET_CONVERSION (charset) == CONVERSION_BIG5_2 )
{
- if (((d = ch - (MIN_CHAR_94x94
- + (XCHARSET_FINAL (charset) - '0') * 94 * 94))
- >= 0)
- && (d < 94 * 94))
- return (((d / 94) + 33) << 8) | (d % 94 + 33);
+ int B1 = d >> 8, B2 = d & 0xFF;
+ unsigned int I
+ = (B1 - 0xA1) * BIG5_SAME_ROW + B2
+ - (B2 < 0x7F ? 0x40 : 0x62);
+
+ if (B1 >= 0xC9)
+ {
+ I -= (BIG5_SAME_ROW) * (0xC9 - 0xA1);
+ return ((I / 94 + 33) << 8) | (I % 94 + 33);
+ }
}
- else if (XCHARSET_CHARS (charset) == 96)
+ 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 )
{
- if (((d = ch - (MIN_CHAR_96x96
- + (XCHARSET_FINAL (charset) - '0') * 96 * 96))
- >= 0)
- && (d < 96 * 96))
- return (((d / 96) + 32) << 8) | (d % 96 + 32);
+ int plane = d / (94 * 60) + 33;
+ int row = (d % (94 * 60)) / 94;
+ int cell = d % 94 + 33;
+
+ if (row < 30)
+ row += 16 + 32;
+ else
+ row += 18 + 32;
+ return (plane << 16) | (row << 8) | cell;
}
+ 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
- return -1;
+ {
+ printf ("Unknown CCS-conversion %d is specified!",
+ XCHARSET_CONVERSION (charset));
+ exit (-1);
+ }
+ }
+ else if ( (XCHARSET_CODE_OFFSET (charset) == 0) ||
+ (XCHARSET_CODE_OFFSET (charset)
+ == XCHARSET_MIN_CODE (charset)) )
+ {
+ int d;
+
+ if (XCHARSET_DIMENSION (charset) == 1)
+ {
+ if (XCHARSET_CHARS (charset) == 94)
+ {
+ if (((d = ch - (MIN_CHAR_94
+ + (XCHARSET_FINAL (charset) - '0') * 94))
+ >= 0)
+ && (d < 94))
+ return d + 33;
+ }
+ else if (XCHARSET_CHARS (charset) == 96)
+ {
+ if (((d = ch - (MIN_CHAR_96
+ + (XCHARSET_FINAL (charset) - '0') * 96))
+ >= 0)
+ && (d < 96))
+ return d + 32;
+ }
+ else
+ return -1;
+ }
+ else if (XCHARSET_DIMENSION (charset) == 2)
+ {
+ if (XCHARSET_CHARS (charset) == 94)
+ {
+ if (((d = ch - (MIN_CHAR_94x94
+ +
+ (XCHARSET_FINAL (charset) - '0') * 94 * 94))
+ >= 0)
+ && (d < 94 * 94))
+ return (((d / 94) + 33) << 8) | (d % 94 + 33);
+ }
+ else if (XCHARSET_CHARS (charset) == 96)
+ {
+ if (((d = ch - (MIN_CHAR_96x96
+ +
+ (XCHARSET_FINAL (charset) - '0') * 96 * 96))
+ >= 0)
+ && (d < 96 * 96))
+ return (((d / 96) + 32) << 8) | (d % 96 + 32);
+ }
+ else
+ return -1;
+ }
}
}
return -1;
return c & 0x7F;
}
/*
- else if ((MIN_CHAR_GREEK <= c) && (c <= MAX_CHAR_GREEK))
- {
- *charset = Vcharset_greek_iso8859_7;
- return c - MIN_CHAR_GREEK + 0x20;
- }
- else if ((MIN_CHAR_CYRILLIC <= c) && (c <= MAX_CHAR_CYRILLIC))
- {
- *charset = Vcharset_cyrillic_iso8859_5;
- return c - MIN_CHAR_CYRILLIC + 0x20;
- }
- */
else if ((MIN_CHAR_HEBREW <= c) && (c <= MAX_CHAR_HEBREW))
{
*charset = Vcharset_hebrew_iso8859_8;
return c - MIN_CHAR_HEBREW + 0x20;
}
+ */
else if ((MIN_CHAR_THAI <= c) && (c <= MAX_CHAR_THAI))
{
*charset = Vcharset_thai_tis620;
*charset = Vcharset_ucs_bmp;
return c;
}
+ else if (c <= MAX_CHAR_SMP)
+ {
+ *charset = Vcharset_ucs_smp;
+ return c - MIN_CHAR_SMP;
+ }
+ else if (c <= MAX_CHAR_SIP)
+ {
+ *charset = Vcharset_ucs_sip;
+ return c - MIN_CHAR_SIP;
+ }
else if (c < MIN_CHAR_DAIKANWA)
{
*charset = Vcharset_ucs;
return c;
}
- /*
else if (c <= MAX_CHAR_DAIKANWA)
{
*charset = Vcharset_ideograph_daikanwa;
return c - MIN_CHAR_DAIKANWA;
}
- */
- else if (c <= MAX_CHAR_MOJIKYO)
- {
- *charset = Vcharset_mojikyo;
- return c - MIN_CHAR_MOJIKYO;
- }
else if (c < MIN_CHAR_94)
{
*charset = Vcharset_ucs;
}
else if (c <= MAX_CHAR_94)
{
- *charset = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_94,
+ *charset = CHARSET_BY_ATTRIBUTES (94, 1,
((c - MIN_CHAR_94) / 94) + '0',
CHARSET_LEFT_TO_RIGHT);
if (!NILP (*charset))
}
else if (c <= MAX_CHAR_96)
{
- *charset = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_96,
+ *charset = CHARSET_BY_ATTRIBUTES (96, 1,
((c - MIN_CHAR_96) / 96) + '0',
CHARSET_LEFT_TO_RIGHT);
if (!NILP (*charset))
else if (c <= MAX_CHAR_94x94)
{
*charset
- = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_94X94,
+ = CHARSET_BY_ATTRIBUTES (94, 2,
((c - MIN_CHAR_94x94) / (94 * 94)) + '0',
CHARSET_LEFT_TO_RIGHT);
if (!NILP (*charset))
else if (c <= MAX_CHAR_96x96)
{
*charset
- = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_96X96,
+ = CHARSET_BY_ATTRIBUTES (96, 2,
((c - MIN_CHAR_96x96) / (96 * 96)) + '0',
CHARSET_LEFT_TO_RIGHT);
if (!NILP (*charset))
(struct charset_list_closure*) charset_list_closure;
Lisp_Object *charset_list = chcl->charset_list;
- *charset_list = Fcons (XCHARSET_NAME (value), *charset_list);
+ *charset_list = Fcons (key /* XCHARSET_NAME (value) */, *charset_list);
return 0;
}
}
DEFUN ("charset-name", Fcharset_name, 1, 1, 0, /*
-Return the name of the given charset.
+Return the name of charset CHARSET.
*/
(charset))
{
return XCHARSET_NAME (Fget_charset (charset));
}
+/* #### SJT Should generic properties be allowed? */
DEFUN ("make-charset", Fmake_charset, 3, 3, 0, /*
Define a new character set.
This function is for use with Mule support.
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, 94x94x60, big5-1 or big5-2).
*/
(name, doc_string, props))
{
int id, dimension = 1, chars = 94, graphic = 0, final = 0, columns = -1;
int direction = CHARSET_LEFT_TO_RIGHT;
- int type;
Lisp_Object registry = Qnil;
Lisp_Object charset;
- Lisp_Object rest, keyword, value;
Lisp_Object ccl_program = Qnil;
Lisp_Object short_name = Qnil, long_name = Qnil;
+ Lisp_Object mother = Qnil;
+ int min_code = 0, max_code = 0, code_offset = 0;
int byte_offset = -1;
+ int conversion = 0;
CHECK_SYMBOL (name);
if (!NILP (doc_string))
if (!NILP (charset))
signal_simple_error ("Cannot redefine existing charset", name);
- EXTERNAL_PROPERTY_LIST_LOOP (rest, keyword, value, props)
- {
- if (EQ (keyword, Qshort_name))
- {
- CHECK_STRING (value);
- short_name = value;
- }
+ {
+ EXTERNAL_PROPERTY_LIST_LOOP_3 (keyword, value, props)
+ {
+ if (EQ (keyword, Qshort_name))
+ {
+ CHECK_STRING (value);
+ short_name = value;
+ }
+
+ if (EQ (keyword, Qlong_name))
+ {
+ CHECK_STRING (value);
+ long_name = value;
+ }
+
+ else if (EQ (keyword, Qdimension))
+ {
+ CHECK_INT (value);
+ dimension = XINT (value);
+ if (dimension < 1 ||
+#ifdef UTF2000
+ dimension > 4
+#else
+ dimension > 2
+#endif
+ )
+ signal_simple_error ("Invalid value for 'dimension", value);
+ }
+
+ else if (EQ (keyword, Qchars))
+ {
+ CHECK_INT (value);
+ chars = XINT (value);
+ if (chars != 94 && chars != 96
+#ifdef UTF2000
+ && chars != 128 && chars != 256
+#endif
+ )
+ signal_simple_error ("Invalid value for 'chars", value);
+ }
+
+ else if (EQ (keyword, Qcolumns))
+ {
+ CHECK_INT (value);
+ columns = XINT (value);
+ if (columns != 1 && columns != 2)
+ signal_simple_error ("Invalid value for 'columns", value);
+ }
- if (EQ (keyword, Qlong_name))
- {
- CHECK_STRING (value);
- long_name = value;
- }
+ else if (EQ (keyword, Qgraphic))
+ {
+ CHECK_INT (value);
+ graphic = XINT (value);
+ if (graphic < 0 ||
+#ifdef UTF2000
+ graphic > 2
+#else
+ graphic > 1
+#endif
+ )
+ signal_simple_error ("Invalid value for 'graphic", value);
+ }
- else if (EQ (keyword, Qdimension))
- {
- CHECK_INT (value);
- dimension = XINT (value);
- if (dimension < 1 || dimension > 2)
- signal_simple_error ("Invalid value for 'dimension", value);
- }
+ else if (EQ (keyword, Qregistry))
+ {
+ CHECK_STRING (value);
+ registry = value;
+ }
- else if (EQ (keyword, Qchars))
- {
- CHECK_INT (value);
- chars = XINT (value);
- if (chars != 94 && chars != 96)
- signal_simple_error ("Invalid value for 'chars", value);
- }
+ else if (EQ (keyword, Qdirection))
+ {
+ if (EQ (value, Ql2r))
+ direction = CHARSET_LEFT_TO_RIGHT;
+ else if (EQ (value, Qr2l))
+ direction = CHARSET_RIGHT_TO_LEFT;
+ else
+ signal_simple_error ("Invalid value for 'direction", value);
+ }
- else if (EQ (keyword, Qcolumns))
- {
- CHECK_INT (value);
- columns = XINT (value);
- if (columns != 1 && columns != 2)
- signal_simple_error ("Invalid value for 'columns", value);
- }
+ else if (EQ (keyword, Qfinal))
+ {
+ CHECK_CHAR_COERCE_INT (value);
+ final = XCHAR (value);
+ if (final < '0' || final > '~')
+ signal_simple_error ("Invalid value for 'final", value);
+ }
- else if (EQ (keyword, Qgraphic))
- {
- CHECK_INT (value);
- graphic = XINT (value);
#ifdef UTF2000
- if (graphic < 0 || graphic > 2)
-#else
- if (graphic < 0 || graphic > 1)
-#endif
- signal_simple_error ("Invalid value for 'graphic", value);
- }
+ else if (EQ (keyword, Qmother))
+ {
+ mother = Fget_charset (value);
+ }
- else if (EQ (keyword, Qregistry))
- {
- CHECK_STRING (value);
- registry = value;
- }
+ else if (EQ (keyword, Qmin_code))
+ {
+ CHECK_INT (value);
+ min_code = XUINT (value);
+ }
- else if (EQ (keyword, Qdirection))
- {
- if (EQ (value, Ql2r))
- direction = CHARSET_LEFT_TO_RIGHT;
- else if (EQ (value, Qr2l))
- direction = CHARSET_RIGHT_TO_LEFT;
- else
- signal_simple_error ("Invalid value for 'direction", value);
- }
+ else if (EQ (keyword, Qmax_code))
+ {
+ CHECK_INT (value);
+ max_code = XUINT (value);
+ }
- else if (EQ (keyword, Qfinal))
- {
- CHECK_CHAR_COERCE_INT (value);
- final = XCHAR (value);
- if (final < '0' || final > '~')
- signal_simple_error ("Invalid value for 'final", value);
- }
+ else if (EQ (keyword, Qcode_offset))
+ {
+ CHECK_INT (value);
+ code_offset = XUINT (value);
+ }
- else if (EQ (keyword, Qccl_program))
- {
- CHECK_VECTOR (value);
- ccl_program = value;
- }
+ else if (EQ (keyword, Qconversion))
+ {
+ if (EQ (value, Q94x60))
+ conversion = CONVERSION_94x60;
+ else if (EQ (value, Q94x94x60))
+ conversion = CONVERSION_94x94x60;
+ else if (EQ (value, Qbig5_1))
+ conversion = CONVERSION_BIG5_1;
+ else if (EQ (value, Qbig5_2))
+ conversion = CONVERSION_BIG5_2;
+ else
+ signal_simple_error ("Unrecognized conversion", value);
+ }
- else
- signal_simple_error ("Unrecognized property", keyword);
- }
+#endif
+ else if (EQ (keyword, Qccl_program))
+ {
+ struct ccl_program test_ccl;
+
+ if (setup_ccl_program (&test_ccl, value) < 0)
+ signal_simple_error ("Invalid value for 'ccl-program", value);
+ ccl_program = value;
+ }
+
+ else
+ signal_simple_error ("Unrecognized property", keyword);
+ }
+ }
+#ifndef UTF2000
if (!final)
error ("'final must be specified");
+#endif
if (dimension == 2 && final > 0x5F)
signal_simple_error
("Final must be in the range 0x30 - 0x5F for dimension == 2",
make_char (final));
- if (dimension == 1)
- type = (chars == 94) ? CHARSET_TYPE_94 : CHARSET_TYPE_96;
- else
- type = (chars == 94) ? CHARSET_TYPE_94X94 : CHARSET_TYPE_96X96;
-
- if (!NILP (CHARSET_BY_ATTRIBUTES (type, final, CHARSET_LEFT_TO_RIGHT)) ||
- !NILP (CHARSET_BY_ATTRIBUTES (type, final, CHARSET_RIGHT_TO_LEFT)))
+ if (!NILP (CHARSET_BY_ATTRIBUTES (chars, dimension, final,
+ CHARSET_LEFT_TO_RIGHT)) ||
+ !NILP (CHARSET_BY_ATTRIBUTES (chars, dimension, final,
+ CHARSET_RIGHT_TO_LEFT)))
error
("Character set already defined for this DIMENSION/CHARS/FINAL combo");
charset = make_charset (id, name, chars, dimension, columns, graphic,
final, direction, short_name, long_name,
doc_string, registry,
- Qnil, 0, 0, 0, byte_offset);
+ Qnil, min_code, max_code, code_offset, byte_offset,
+ mother, conversion);
if (!NILP (ccl_program))
XCHARSET_CCL_PROGRAM (charset) = ccl_program;
return charset;
doc_string, registry,
#ifdef UTF2000
CHARSET_DECODING_TABLE(cs),
- CHARSET_UCS_MIN(cs),
- CHARSET_UCS_MAX(cs),
+ CHARSET_MIN_CODE(cs),
+ CHARSET_MAX_CODE(cs),
CHARSET_CODE_OFFSET(cs),
- CHARSET_BYTE_OFFSET(cs)
+ CHARSET_BYTE_OFFSET(cs),
+ CHARSET_MOTHER(cs),
+ CHARSET_CONVERSION (cs)
#else
- Qnil, 0, 0, 0, 0
+ Qnil, 0, 0, 0, 0, Qnil, 0
#endif
);
(dimension, chars, final, direction))
{
int dm, ch, fi, di = -1;
- int type;
Lisp_Object obj = Qnil;
CHECK_INT (dimension);
signal_simple_error
("Final must be in the range 0x30 - 0x5F for dimension == 2", final);
- if (dm == 1)
- type = (ch == 94) ? CHARSET_TYPE_94 : CHARSET_TYPE_96;
- else
- type = (ch == 94) ? CHARSET_TYPE_94X94 : CHARSET_TYPE_96X96;
-
- if (di == -1)
+ if (di == -1)
{
- obj = CHARSET_BY_ATTRIBUTES (type, fi, CHARSET_LEFT_TO_RIGHT);
+ obj = CHARSET_BY_ATTRIBUTES (ch, dm, fi, CHARSET_LEFT_TO_RIGHT);
if (NILP (obj))
- obj = CHARSET_BY_ATTRIBUTES (type, fi, CHARSET_RIGHT_TO_LEFT);
+ obj = CHARSET_BY_ATTRIBUTES (ch, dm, fi, CHARSET_RIGHT_TO_LEFT);
}
else
- obj = CHARSET_BY_ATTRIBUTES (type, fi, di);
+ obj = CHARSET_BY_ATTRIBUTES (ch, dm, fi, di);
if (CHARSETP (obj))
return XCHARSET_NAME (obj);
}
DEFUN ("charset-property", Fcharset_property, 2, 2, 0, /*
-Return property PROP of CHARSET.
+Return property PROP of CHARSET, a charset object or symbol naming a charset.
Recognized properties are those listed in `make-charset', as well as
'name and 'doc-string.
*/
if (EQ (prop, Qdimension)) return make_int (CHARSET_DIMENSION (cs));
if (EQ (prop, Qcolumns)) return make_int (CHARSET_COLUMNS (cs));
if (EQ (prop, Qgraphic)) return make_int (CHARSET_GRAPHIC (cs));
- if (EQ (prop, Qfinal)) return make_char (CHARSET_FINAL (cs));
+ if (EQ (prop, Qfinal)) return CHARSET_FINAL (cs) == 0 ?
+ Qnil : make_char (CHARSET_FINAL (cs));
if (EQ (prop, Qchars)) return make_int (CHARSET_CHARS (cs));
if (EQ (prop, Qregistry)) return CHARSET_REGISTRY (cs);
if (EQ (prop, Qccl_program)) return CHARSET_CCL_PROGRAM (cs);
if (EQ (prop, Qreverse_direction_charset))
{
Lisp_Object obj = CHARSET_REVERSE_DIRECTION_CHARSET (cs);
- if (NILP (obj))
- return Qnil;
- else
- return XCHARSET_NAME (obj);
+ /* #### Is this translation OK? If so, error checking sufficient? */
+ return CHARSETP (obj) ? XCHARSET_NAME (obj) : obj;
}
+#ifdef UTF2000
+ if (EQ (prop, Qmother))
+ return CHARSET_MOTHER (cs);
+ if (EQ (prop, Qmin_code))
+ return make_int (CHARSET_MIN_CODE (cs));
+ if (EQ (prop, Qmax_code))
+ return make_int (CHARSET_MAX_CODE (cs));
+#endif
signal_simple_error ("Unrecognized charset property name", prop);
return Qnil; /* not reached */
}
*/
(charset, ccl_program))
{
+ struct ccl_program test_ccl;
+
charset = Fget_charset (charset);
- CHECK_VECTOR (ccl_program);
+ if (setup_ccl_program (&test_ccl, ccl_program) < 0)
+ signal_simple_error ("Invalid ccl-program", ccl_program);
XCHARSET_CCL_PROGRAM (charset) = ccl_program;
return Qnil;
}
(charset, table))
{
struct Lisp_Charset *cs;
- Lisp_Object old_table;
size_t i;
+ int byte_offset;
charset = Fget_charset (charset);
cs = XCHARSET (charset);
- if (EQ (table, Qnil))
+ if (NILP (table))
{
- CHARSET_DECODING_TABLE(cs) = table;
+ CHARSET_DECODING_TABLE(cs) = Qnil;
return table;
}
else if (VECTORP (table))
{
int ccs_len = CHARSET_BYTE_SIZE (cs);
-
- if (XVECTOR_LENGTH (table) > ccs_len)
- args_out_of_range (table, make_int (CHARSET_CHARS (cs)));
- old_table = CHARSET_DECODING_TABLE(cs);
- CHARSET_DECODING_TABLE(cs) = table;
+ int ret = decoding_table_check_elements (table,
+ CHARSET_DIMENSION (cs),
+ ccs_len);
+ if (ret)
+ {
+ if (ret == -1)
+ signal_simple_error ("Too big table", table);
+ else if (ret == -2)
+ signal_simple_error ("Invalid element is found", table);
+ else
+ signal_simple_error ("Something wrong", table);
+ }
+ CHARSET_DECODING_TABLE(cs) = Qnil;
}
else
signal_error (Qwrong_type_argument,
list2 (build_translated_string ("vector-or-nil-p"),
table));
- /* signal_simple_error ("Wrong type argument: vector-or-nil-p", table); */
+ byte_offset = CHARSET_BYTE_OFFSET (cs);
switch (CHARSET_DIMENSION (cs))
{
case 1:
Lisp_Object c = XVECTOR_DATA(table)[i];
if (CHARP (c))
- put_char_attribute
- (c, charset,
- make_int (i + CHARSET_BYTE_OFFSET (cs)));
+ Fput_char_attribute (c, XCHARSET_NAME (charset),
+ make_int (i + byte_offset));
}
break;
case 2:
{
size_t j;
- if (XVECTOR_LENGTH (v) > CHARSET_CHARS (cs))
- {
- CHARSET_DECODING_TABLE(cs) = old_table;
- args_out_of_range (v, make_int (CHARSET_CHARS (cs)));
- }
for (j = 0; j < XVECTOR_LENGTH (v); j++)
{
Lisp_Object c = XVECTOR_DATA(v)[j];
if (CHARP (c))
- put_char_attribute
- (c, charset,
- make_int ( ((i + CHARSET_BYTE_OFFSET (cs)) << 8)
- | (j + CHARSET_BYTE_OFFSET (cs)) ));
+ Fput_char_attribute
+ (c, XCHARSET_NAME (charset),
+ make_int ( ( (i + byte_offset) << 8 )
+ | (j + byte_offset)
+ ) );
}
}
else if (CHARP (v))
- put_char_attribute (v, charset,
- make_int (i + CHARSET_BYTE_OFFSET (cs)));
+ Fput_char_attribute (v, XCHARSET_NAME (charset),
+ make_int (i + byte_offset));
}
break;
}
return table;
}
+
+DEFUN ("save-charset-mapping-table", Fsave_charset_mapping_table, 1, 1, 0, /*
+Save mapping-table of CHARSET.
+*/
+ (charset))
+{
+#ifdef HAVE_DATABASE
+ struct Lisp_Charset *cs;
+ int byte_min, byte_max;
+ Lisp_Object db;
+ Lisp_Object db_file;
+
+ charset = Fget_charset (charset);
+ cs = XCHARSET (charset);
+
+ db_file = char_attribute_system_db_file (CHARSET_NAME (cs),
+ Qsystem_char_id, 1);
+ db = Fopen_database (db_file, Qnil, Qnil, build_string ("w+"), Qnil);
+
+ byte_min = CHARSET_BYTE_OFFSET (cs);
+ byte_max = byte_min + CHARSET_BYTE_SIZE (cs);
+ switch (CHARSET_DIMENSION (cs))
+ {
+ case 1:
+ {
+ Lisp_Object table_c = XCHARSET_DECODING_TABLE (charset);
+ int cell;
+
+ for (cell = byte_min; cell < byte_max; cell++)
+ {
+ Lisp_Object c = get_ccs_octet_table (table_c, charset, cell);
+
+ if (CHARP (c))
+ Fput_database (Fprin1_to_string (make_int (cell), Qnil),
+ Fprin1_to_string (c, Qnil),
+ db, Qt);
+ }
+ }
+ break;
+ case 2:
+ {
+ Lisp_Object table_r = XCHARSET_DECODING_TABLE (charset);
+ int row;
+
+ for (row = byte_min; row < byte_max; row++)
+ {
+ Lisp_Object table_c = get_ccs_octet_table (table_r, charset, row);
+ int cell;
+
+ for (cell = byte_min; cell < byte_max; cell++)
+ {
+ Lisp_Object c = get_ccs_octet_table (table_c, charset, cell);
+
+ if (CHARP (c))
+ Fput_database (Fprin1_to_string (make_int ((row << 8)
+ | cell),
+ Qnil),
+ Fprin1_to_string (c, Qnil),
+ db, Qt);
+ }
+ }
+ }
+ break;
+ case 3:
+ {
+ Lisp_Object table_p = XCHARSET_DECODING_TABLE (charset);
+ int plane;
+
+ for (plane = byte_min; plane < byte_max; plane++)
+ {
+ Lisp_Object table_r
+ = get_ccs_octet_table (table_p, charset, plane);
+ int row;
+
+ for (row = byte_min; row < byte_max; row++)
+ {
+ Lisp_Object table_c
+ = get_ccs_octet_table (table_r, charset, row);
+ int cell;
+
+ for (cell = byte_min; cell < byte_max; cell++)
+ {
+ Lisp_Object c = get_ccs_octet_table (table_c, charset,
+ cell);
+
+ if (CHARP (c))
+ Fput_database (Fprin1_to_string (make_int ((plane << 16)
+ | (row << 8)
+ | cell),
+ Qnil),
+ Fprin1_to_string (c, Qnil),
+ db, Qt);
+ }
+ }
+ }
+ }
+ break;
+ default:
+ {
+ Lisp_Object table_g = XCHARSET_DECODING_TABLE (charset);
+ int group;
+
+ for (group = byte_min; group < byte_max; group++)
+ {
+ Lisp_Object table_p
+ = get_ccs_octet_table (table_g, charset, group);
+ int plane;
+
+ for (plane = byte_min; plane < byte_max; plane++)
+ {
+ Lisp_Object table_r
+ = get_ccs_octet_table (table_p, charset, plane);
+ int row;
+
+ for (row = byte_min; row < byte_max; row++)
+ {
+ Lisp_Object table_c
+ = get_ccs_octet_table (table_r, charset, row);
+ int cell;
+
+ for (cell = byte_min; cell < byte_max; cell++)
+ {
+ Lisp_Object c
+ = get_ccs_octet_table (table_c, charset, cell);
+
+ if (CHARP (c))
+ Fput_database (Fprin1_to_string
+ (make_int (( group << 24)
+ | (plane << 16)
+ | (row << 8)
+ | cell),
+ Qnil),
+ Fprin1_to_string (c, Qnil),
+ db, Qt);
+ }
+ }
+ }
+ }
+ }
+ }
+ return Fclose_database (db);
+#else
+ return Qnil;
#endif
+}
+
+#ifdef HAVE_CHISE_CLIENT
+Emchar
+load_char_decoding_entry_maybe (Lisp_Object ccs, int code_point)
+{
+ Lisp_Object db;
+ Lisp_Object db_file
+ = char_attribute_system_db_file (XCHARSET_NAME(ccs), Qsystem_char_id,
+ 0);
+
+ db = Fopen_database (db_file, Qnil, Qnil, build_string ("r"), Qnil);
+ if (!NILP (db))
+ {
+ Lisp_Object ret
+ = Fget_database (Fprin1_to_string (make_int (code_point), Qnil),
+ db, Qnil);
+ if (!NILP (ret))
+ {
+ ret = Fread (ret);
+ if (CHARP (ret))
+ {
+ decoding_table_put_char (ccs, code_point, ret);
+ Fclose_database (db);
+ return XCHAR (ret);
+ }
+ }
+ Fclose_database (db);
+ }
+ return -1;
+}
+#endif /* HAVE_CHISE_CLIENT */
+#endif /* UTF2000 */
\f
/************************************************************************/
/************************************************************************/
#ifdef UTF2000
-DEFUN ("decode-char", Fdecode_char, 2, 2, 0, /*
+DEFUN ("decode-char", Fdecode_char, 2, 3, 0, /*
Make a character from CHARSET and code-point CODE.
+If DEFINED_ONLY is non-nil, builtin character is not returned.
+If corresponding character is not found, nil is returned.
+*/
+ (charset, code, defined_only))
+{
+ int c;
+
+ charset = Fget_charset (charset);
+ CHECK_INT (code);
+ c = XINT (code);
+ if (XCHARSET_GRAPHIC (charset) == 1)
+ c &= 0x7F7F7F7F;
+ if (NILP (defined_only))
+ c = DECODE_CHAR (charset, c);
+ else
+ c = decode_defined_char (charset, c);
+ return c >= 0 ? make_char (c) : Qnil;
+}
+
+DEFUN ("decode-builtin-char", Fdecode_builtin_char, 2, 2, 0, /*
+Make a builtin character from CHARSET and code-point CODE.
*/
(charset, code))
{
charset = Fget_charset (charset);
CHECK_INT (code);
+ if (EQ (charset, Vcharset_latin_viscii))
+ {
+ Lisp_Object chr = Fdecode_char (charset, code, Qnil);
+ Lisp_Object ret;
+
+ if (!NILP (chr))
+ {
+ if (!NILP
+ (ret = Fget_char_attribute (chr,
+ Vcharset_latin_viscii_lower,
+ Qnil)))
+ {
+ charset = Vcharset_latin_viscii_lower;
+ code = ret;
+ }
+ else if (!NILP
+ (ret = Fget_char_attribute (chr,
+ Vcharset_latin_viscii_upper,
+ Qnil)))
+ {
+ charset = Vcharset_latin_viscii_upper;
+ code = ret;
+ }
+ }
+ }
c = XINT (code);
+#if 0
if (XCHARSET_GRAPHIC (charset) == 1)
c &= 0x7F7F7F7F;
- return make_char (DECODE_CHAR (charset, c));
+#endif
+ c = decode_builtin_char (charset, c);
+ return c >= 0 ? make_char (c) : Fdecode_char (charset, code, Qnil);
}
#endif
CHECK_INT (arg1);
/* It is useful (and safe, according to Olivier Galibert) to strip
- the 8th bit off ARG1 and ARG2 becaue it allows programmers to
+ the 8th bit off ARG1 and ARG2 because it allows programmers to
write (make-char 'latin-iso8859-2 CODE) where code is the actual
Latin 2 code of the character. */
#ifdef UTF2000
}
DEFUN ("char-charset", Fchar_charset, 1, 1, 0, /*
-Return the character set of char CH.
+Return the character set of CHARACTER.
*/
- (ch))
+ (character))
{
- CHECK_CHAR_COERCE_INT (ch);
+ CHECK_CHAR_COERCE_INT (character);
- return XCHARSET_NAME (CHAR_CHARSET (XCHAR (ch)));
+ return XCHARSET_NAME (CHAR_CHARSET (XCHAR (character)));
}
DEFUN ("char-octet", Fchar_octet, 1, 2, 0, /*
-Return the octet numbered N (should be 0 or 1) of char CH.
+Return the octet numbered N (should be 0 or 1) of CHARACTER.
N defaults to 0 if omitted.
*/
- (ch, n))
+ (character, n))
{
Lisp_Object charset;
int octet0, octet1;
- CHECK_CHAR_COERCE_INT (ch);
+ CHECK_CHAR_COERCE_INT (character);
- BREAKUP_CHAR (XCHAR (ch), charset, octet0, octet1);
+ BREAKUP_CHAR (XCHAR (character), charset, octet0, octet1);
if (NILP (n) || EQ (n, Qzero))
return make_int (octet0);
signal_simple_error ("Octet number must be 0 or 1", n);
}
+#ifdef UTF2000
+DEFUN ("encode-char", Fencode_char, 2, 2, 0, /*
+Return code-point of CHARACTER in specified CHARSET.
+*/
+ (character, charset))
+{
+ int code_point;
+
+ CHECK_CHAR_COERCE_INT (character);
+ charset = Fget_charset (charset);
+ code_point = charset_code_point (charset, XCHAR (character));
+ if (code_point >= 0)
+ return make_int (code_point);
+ else
+ return Qnil;
+}
+#endif
+
DEFUN ("split-char", Fsplit_char, 1, 1, 0, /*
-Return list of charset and one or two position-codes of CHAR.
+Return list of charset and one or two position-codes of CHARACTER.
*/
(character))
{
void
syms_of_mule_charset (void)
{
-#ifdef UTF2000
- INIT_LRECORD_IMPLEMENTATION (byte_table);
- INIT_LRECORD_IMPLEMENTATION (char_id_table);
-#endif
INIT_LRECORD_IMPLEMENTATION (charset);
DEFSUBR (Fcharsetp);
DEFSUBR (Fset_charset_ccl_program);
DEFSUBR (Fset_charset_registry);
#ifdef UTF2000
- DEFSUBR (Fchar_attribute_alist);
- DEFSUBR (Fget_char_attribute);
- DEFSUBR (Fput_char_attribute);
- DEFSUBR (Fremove_char_attribute);
- DEFSUBR (Fdefine_char);
- DEFSUBR (Fchar_variants);
- DEFSUBR (Fget_composite_char);
DEFSUBR (Fcharset_mapping_table);
DEFSUBR (Fset_charset_mapping_table);
#endif
#ifdef UTF2000
DEFSUBR (Fdecode_char);
+ DEFSUBR (Fdecode_builtin_char);
+ DEFSUBR (Fencode_char);
+ DEFSUBR (Fsave_charset_mapping_table);
#endif
DEFSUBR (Fmake_char);
DEFSUBR (Fchar_charset);
defsymbol (&Qreverse_direction_charset, "reverse-direction-charset");
defsymbol (&Qshort_name, "short-name");
defsymbol (&Qlong_name, "long-name");
+#ifdef UTF2000
+ defsymbol (&Qmother, "mother");
+ defsymbol (&Qmin_code, "min-code");
+ defsymbol (&Qmax_code, "max-code");
+ defsymbol (&Qcode_offset, "code-offset");
+ defsymbol (&Qconversion, "conversion");
+ defsymbol (&Q94x60, "94x60");
+ defsymbol (&Q94x94x60, "94x94x60");
+ defsymbol (&Qbig5_1, "big5-1");
+ defsymbol (&Qbig5_2, "big5-2");
+#endif
defsymbol (&Ql2r, "l2r");
defsymbol (&Qr2l, "r2l");
defsymbol (&Qlatin_iso8859_9, "latin-iso8859-9");
defsymbol (&Qjapanese_jisx0208_1978, "japanese-jisx0208-1978");
defsymbol (&Qchinese_gb2312, "chinese-gb2312");
+ defsymbol (&Qchinese_gb12345, "chinese-gb12345");
defsymbol (&Qjapanese_jisx0208, "japanese-jisx0208");
defsymbol (&Qjapanese_jisx0208_1990, "japanese-jisx0208-1990");
defsymbol (&Qkorean_ksc5601, "korean-ksc5601");
defsymbol (&Qchinese_cns11643_1, "chinese-cns11643-1");
defsymbol (&Qchinese_cns11643_2, "chinese-cns11643-2");
#ifdef UTF2000
- defsymbol (&Qname, "name");
- defsymbol (&Q_ucs, "->ucs");
- defsymbol (&Q_decomposition, "->decomposition");
- defsymbol (&Qcompat, "compat");
- defsymbol (&Qisolated, "isolated");
- defsymbol (&Qinitial, "initial");
- defsymbol (&Qmedial, "medial");
- defsymbol (&Qfinal, "final");
- defsymbol (&Qvertical, "vertical");
- defsymbol (&QnoBreak, "noBreak");
- defsymbol (&Qfraction, "fraction");
- defsymbol (&Qsuper, "super");
- defsymbol (&Qsub, "sub");
- defsymbol (&Qcircle, "circle");
- defsymbol (&Qsquare, "square");
- defsymbol (&Qwide, "wide");
- defsymbol (&Qnarrow, "narrow");
- defsymbol (&Qsmall, "small");
- defsymbol (&Qfont, "font");
defsymbol (&Qucs, "ucs");
defsymbol (&Qucs_bmp, "ucs-bmp");
+ defsymbol (&Qucs_smp, "ucs-smp");
+ defsymbol (&Qucs_sip, "ucs-sip");
+ defsymbol (&Qucs_cns, "ucs-cns");
+ defsymbol (&Qucs_jis, "ucs-jis");
+ defsymbol (&Qucs_ks, "ucs-ks");
+ defsymbol (&Qucs_big5, "ucs-big5");
defsymbol (&Qlatin_viscii, "latin-viscii");
defsymbol (&Qlatin_tcvn5712, "latin-tcvn5712");
defsymbol (&Qlatin_viscii_lower, "latin-viscii-lower");
defsymbol (&Qlatin_viscii_upper, "latin-viscii-upper");
defsymbol (&Qvietnamese_viscii_lower, "vietnamese-viscii-lower");
defsymbol (&Qvietnamese_viscii_upper, "vietnamese-viscii-upper");
+ 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_gt_pj_3, "ideograph-gt-pj-3");
+ defsymbol (&Qideograph_gt_pj_4, "ideograph-gt-pj-4");
+ defsymbol (&Qideograph_gt_pj_5, "ideograph-gt-pj-5");
+ defsymbol (&Qideograph_gt_pj_6, "ideograph-gt-pj-6");
+ defsymbol (&Qideograph_gt_pj_7, "ideograph-gt-pj-7");
+ defsymbol (&Qideograph_gt_pj_8, "ideograph-gt-pj-8");
+ defsymbol (&Qideograph_gt_pj_9, "ideograph-gt-pj-9");
+ defsymbol (&Qideograph_gt_pj_10, "ideograph-gt-pj-10");
+ defsymbol (&Qideograph_gt_pj_11, "ideograph-gt-pj-11");
+ defsymbol (&Qideograph_daikanwa_2, "ideograph-daikanwa-2");
defsymbol (&Qideograph_daikanwa, "ideograph-daikanwa");
- defsymbol (&Qmojikyo, "mojikyo");
- defsymbol (&Qmojikyo_pj_1, "mojikyo-pj-1");
- defsymbol (&Qmojikyo_pj_2, "mojikyo-pj-2");
- defsymbol (&Qmojikyo_pj_3, "mojikyo-pj-3");
- defsymbol (&Qmojikyo_pj_4, "mojikyo-pj-4");
- defsymbol (&Qmojikyo_pj_5, "mojikyo-pj-5");
- defsymbol (&Qmojikyo_pj_6, "mojikyo-pj-6");
- defsymbol (&Qmojikyo_pj_7, "mojikyo-pj-7");
- defsymbol (&Qmojikyo_pj_8, "mojikyo-pj-8");
- defsymbol (&Qmojikyo_pj_9, "mojikyo-pj-9");
- defsymbol (&Qmojikyo_pj_10, "mojikyo-pj-10");
- defsymbol (&Qmojikyo_pj_11, "mojikyo-pj-11");
- defsymbol (&Qmojikyo_pj_12, "mojikyo-pj-12");
- defsymbol (&Qmojikyo_pj_13, "mojikyo-pj-13");
- defsymbol (&Qmojikyo_pj_14, "mojikyo-pj-14");
- defsymbol (&Qmojikyo_pj_15, "mojikyo-pj-15");
- defsymbol (&Qmojikyo_pj_16, "mojikyo-pj-16");
- defsymbol (&Qmojikyo_pj_17, "mojikyo-pj-17");
- defsymbol (&Qmojikyo_pj_18, "mojikyo-pj-18");
- defsymbol (&Qmojikyo_pj_19, "mojikyo-pj-19");
- defsymbol (&Qmojikyo_pj_20, "mojikyo-pj-20");
- defsymbol (&Qmojikyo_pj_21, "mojikyo-pj-21");
+ defsymbol (&Qchinese_big5, "chinese-big5");
+ /* 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_4, "ideograph-hanziku-4");
+ defsymbol (&Qideograph_hanziku_5, "ideograph-hanziku-5");
+ defsymbol (&Qideograph_hanziku_6, "ideograph-hanziku-6");
+ defsymbol (&Qideograph_hanziku_7, "ideograph-hanziku-7");
+ defsymbol (&Qideograph_hanziku_8, "ideograph-hanziku-8");
+ defsymbol (&Qideograph_hanziku_9, "ideograph-hanziku-9");
+ 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
defsymbol (&Qchinese_big5_1, "chinese-big5-1");
int k;
#endif
- chlook = xnew (struct charset_lookup);
- dumpstruct (&chlook, &charset_lookup_description);
+ chlook = xnew_and_zero (struct charset_lookup); /* zero for Purify. */
+ dump_add_root_struct_ptr (&chlook, &charset_lookup_description);
/* Table of charsets indexed by leading byte. */
for (i = 0; i < countof (chlook->charset_by_leading_byte); i++)
#endif
#ifdef UTF2000
- Vutf_2000_version = build_string("0.15 (Sangō)");
- DEFVAR_LISP ("utf-2000-version", &Vutf_2000_version /*
-Version number of UTF-2000.
-*/ );
-
- staticpro (&Vcharacter_attribute_table);
- Vcharacter_attribute_table = make_char_id_table (Qnil, 0);
-
- staticpro (&Vcharacter_name_table);
- Vcharacter_name_table = make_char_id_table (Qnil, 0);
-
- /* staticpro (&Vcharacter_composition_table); */
- Vcharacter_composition_table = make_char_id_table (Qnil, -1);
-
- staticpro (&Vcharacter_variant_table);
- Vcharacter_variant_table = make_char_id_table (Qnil, 0);
-
Vdefault_coded_charset_priority_list = Qnil;
DEFVAR_LISP ("default-coded-charset-priority-list",
&Vdefault_coded_charset_priority_list /*
build_string ("UCS"),
build_string ("ISO/IEC 10646"),
build_string (""),
- Qnil, 0, 0xFFFFFFF, 0, 0);
+ 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,
1, 2, 0, CHARSET_LEFT_TO_RIGHT,
build_string ("BMP"),
- build_string ("BMP"),
+ build_string ("UCS-BMP"),
build_string ("ISO/IEC 10646 Group 0 Plane 0 (BMP)"),
- build_string ("\\(ISO10646.*-1\\|UNICODE[23]?-0\\)"),
- Qnil, 0, 0xFFFF, 0, 0);
+ build_string
+ ("\\(ISO10646.*-[01]\\|UCS00-0\\|UNICODE[23]?-0\\)"),
+ Qnil, 0, 0xFFFF, 0, 0, Qnil, CONVERSION_IDENTICAL);
+ staticpro (&Vcharset_ucs_smp);
+ Vcharset_ucs_smp =
+ make_charset (LEADING_BYTE_UCS_SMP, Qucs_smp, 256, 2,
+ 1, 2, 0, CHARSET_LEFT_TO_RIGHT,
+ build_string ("SMP"),
+ build_string ("UCS-SMP"),
+ build_string ("ISO/IEC 10646 Group 0 Plane 1 (SMP)"),
+ build_string ("UCS00-1"),
+ Qnil, MIN_CHAR_SMP, MAX_CHAR_SMP,
+ MIN_CHAR_SMP, 0, Qnil, CONVERSION_IDENTICAL);
+ staticpro (&Vcharset_ucs_sip);
+ Vcharset_ucs_sip =
+ make_charset (LEADING_BYTE_UCS_SIP, Qucs_sip, 256, 2,
+ 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+ build_string ("SIP"),
+ build_string ("UCS-SIP"),
+ build_string ("ISO/IEC 10646 Group 0 Plane 2 (SIP)"),
+ build_string ("\\(ISO10646.*-2\\|UCS00-2\\)"),
+ Qnil, MIN_CHAR_SIP, MAX_CHAR_SIP,
+ MIN_CHAR_SIP, 0, Qnil, CONVERSION_IDENTICAL);
+ staticpro (&Vcharset_ucs_cns);
+ Vcharset_ucs_cns =
+ make_charset (LEADING_BYTE_UCS_CNS, Qucs_cns, 256, 3,
+ 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+ build_string ("UCS for CNS"),
+ build_string ("UCS for CNS 11643"),
+ build_string ("ISO/IEC 10646 for CNS 11643"),
+ build_string (""),
+ 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 (""),
+ 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,
+ 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+ build_string ("UCS for KS"),
+ build_string ("UCS for CCS defined by KS"),
+ build_string ("ISO/IEC 10646 for Korean Standards"),
+ build_string (""),
+ 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,
+ 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+ build_string ("UCS for Big5"),
+ build_string ("UCS for Big5"),
+ build_string ("ISO/IEC 10646 for Big5"),
+ build_string (""),
+ Qnil, 0, 0, 0, 0, Vcharset_ucs, CONVERSION_IDENTICAL);
#else
# define MIN_CHAR_THAI 0
# define MAX_CHAR_THAI 0
-# define MIN_CHAR_HEBREW 0
-# define MAX_CHAR_HEBREW 0
+ /* # define MIN_CHAR_HEBREW 0 */
+ /* # define MAX_CHAR_HEBREW 0 */
# define MIN_CHAR_HALFWIDTH_KATAKANA 0
# define MAX_CHAR_HALFWIDTH_KATAKANA 0
#endif
build_string ("ASCII)"),
build_string ("ASCII (ISO646 IRV)"),
build_string ("\\(iso8859-[0-9]*\\|-ascii\\)"),
- Qnil, 0, 0x7F, 0, 0);
+ Qnil, 0, 0x7F, 0, 0, Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_control_1);
Vcharset_control_1 =
make_charset (LEADING_BYTE_CONTROL_1, Qcontrol_1, 94, 1,
build_string ("Control characters"),
build_string ("Control characters 128-191"),
build_string (""),
- Qnil, 0x80, 0x9F, 0, 0);
+ Qnil, 0x80, 0x9F, 0x80, 0, Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_latin_iso8859_1);
Vcharset_latin_iso8859_1 =
make_charset (LEADING_BYTE_LATIN_ISO8859_1, Qlatin_iso8859_1, 96, 1,
build_string ("ISO8859-1 (Latin-1)"),
build_string ("ISO8859-1 (Latin-1)"),
build_string ("iso8859-1"),
- Qnil, 0xA0, 0xFF, 0, 32);
+ Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_latin_iso8859_2);
Vcharset_latin_iso8859_2 =
make_charset (LEADING_BYTE_LATIN_ISO8859_2, Qlatin_iso8859_2, 96, 1,
build_string ("ISO8859-2 (Latin-2)"),
build_string ("ISO8859-2 (Latin-2)"),
build_string ("iso8859-2"),
- Qnil, 0, 0, 0, 32);
+ Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_latin_iso8859_3);
Vcharset_latin_iso8859_3 =
make_charset (LEADING_BYTE_LATIN_ISO8859_3, Qlatin_iso8859_3, 96, 1,
build_string ("ISO8859-3 (Latin-3)"),
build_string ("ISO8859-3 (Latin-3)"),
build_string ("iso8859-3"),
- Qnil, 0, 0, 0, 32);
+ Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_latin_iso8859_4);
Vcharset_latin_iso8859_4 =
make_charset (LEADING_BYTE_LATIN_ISO8859_4, Qlatin_iso8859_4, 96, 1,
build_string ("ISO8859-4 (Latin-4)"),
build_string ("ISO8859-4 (Latin-4)"),
build_string ("iso8859-4"),
- Qnil, 0, 0, 0, 32);
+ Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_thai_tis620);
Vcharset_thai_tis620 =
make_charset (LEADING_BYTE_THAI_TIS620, Qthai_tis620, 96, 1,
build_string ("TIS620 (Thai)"),
build_string ("TIS620.2529 (Thai)"),
build_string ("tis620"),
- Qnil, MIN_CHAR_THAI, MAX_CHAR_THAI, 0, 32);
+ Qnil, MIN_CHAR_THAI, MAX_CHAR_THAI,
+ MIN_CHAR_THAI, 32, Qnil, CONVERSION_96);
staticpro (&Vcharset_greek_iso8859_7);
Vcharset_greek_iso8859_7 =
make_charset (LEADING_BYTE_GREEK_ISO8859_7, Qgreek_iso8859_7, 96, 1,
build_string ("ISO8859-7 (Greek)"),
build_string ("ISO8859-7 (Greek)"),
build_string ("iso8859-7"),
- Qnil,
- 0 /* MIN_CHAR_GREEK */,
- 0 /* MAX_CHAR_GREEK */, 0, 32);
+ Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_arabic_iso8859_6);
Vcharset_arabic_iso8859_6 =
make_charset (LEADING_BYTE_ARABIC_ISO8859_6, Qarabic_iso8859_6, 96, 1,
build_string ("ISO8859-6 (Arabic)"),
build_string ("ISO8859-6 (Arabic)"),
build_string ("iso8859-6"),
- Qnil, 0, 0, 0, 32);
+ Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_hebrew_iso8859_8);
Vcharset_hebrew_iso8859_8 =
make_charset (LEADING_BYTE_HEBREW_ISO8859_8, Qhebrew_iso8859_8, 96, 1,
build_string ("ISO8859-8 (Hebrew)"),
build_string ("ISO8859-8 (Hebrew)"),
build_string ("iso8859-8"),
- Qnil, MIN_CHAR_HEBREW, MAX_CHAR_HEBREW, 0, 32);
+ Qnil,
+ 0 /* MIN_CHAR_HEBREW */,
+ 0 /* MAX_CHAR_HEBREW */, 0, 32,
+ Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_katakana_jisx0201);
Vcharset_katakana_jisx0201 =
make_charset (LEADING_BYTE_KATAKANA_JISX0201, Qkatakana_jisx0201, 94, 1,
build_string ("JISX0201.1976 (Japanese Kana)"),
build_string ("JISX0201.1976 Japanese Kana"),
build_string ("jisx0201\\.1976"),
- Qnil, 0, 0, 0, 33);
+ Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_latin_jisx0201);
Vcharset_latin_jisx0201 =
make_charset (LEADING_BYTE_LATIN_JISX0201, Qlatin_jisx0201, 94, 1,
build_string ("JISX0201.1976 (Japanese Roman)"),
build_string ("JISX0201.1976 Japanese Roman"),
build_string ("jisx0201\\.1976"),
- Qnil, 0, 0, 0, 33);
+ Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_cyrillic_iso8859_5);
Vcharset_cyrillic_iso8859_5 =
make_charset (LEADING_BYTE_CYRILLIC_ISO8859_5, Qcyrillic_iso8859_5, 96, 1,
build_string ("ISO8859-5 (Cyrillic)"),
build_string ("ISO8859-5 (Cyrillic)"),
build_string ("iso8859-5"),
- Qnil,
- 0 /* MIN_CHAR_CYRILLIC */,
- 0 /* MAX_CHAR_CYRILLIC */, 0, 32);
+ Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_latin_iso8859_9);
Vcharset_latin_iso8859_9 =
make_charset (LEADING_BYTE_LATIN_ISO8859_9, Qlatin_iso8859_9, 96, 1,
build_string ("ISO8859-9 (Latin-5)"),
build_string ("ISO8859-9 (Latin-5)"),
build_string ("iso8859-9"),
- Qnil, 0, 0, 0, 32);
+ Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
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, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_chinese_gb2312);
Vcharset_chinese_gb2312 =
make_charset (LEADING_BYTE_CHINESE_GB2312, Qchinese_gb2312, 94, 2,
build_string ("GB2312)"),
build_string ("GB2312 Chinese simplified"),
build_string ("gb2312"),
- Qnil, 0, 0, 0, 33);
+ Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
+ staticpro (&Vcharset_chinese_gb12345);
+ Vcharset_chinese_gb12345 =
+ make_charset (LEADING_BYTE_CHINESE_GB12345, Qchinese_gb12345, 94, 2,
+ 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
+ build_string ("G1"),
+ build_string ("GB 12345)"),
+ build_string ("GB 12345-1990"),
+ build_string ("GB12345\\(\\.1990\\)?-0"),
+ Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_japanese_jisx0208);
Vcharset_japanese_jisx0208 =
make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qjapanese_jisx0208, 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, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
#ifdef UTF2000
staticpro (&Vcharset_japanese_jisx0208_1990);
Vcharset_japanese_jisx0208_1990 =
build_string ("jisx0208\\.1990"),
Qnil,
MIN_CHAR_JIS_X0208_1990,
- MAX_CHAR_JIS_X0208_1990, 0, 33);
+ MAX_CHAR_JIS_X0208_1990, MIN_CHAR_JIS_X0208_1990, 33,
+ Qnil, CONVERSION_94x94);
#endif
staticpro (&Vcharset_korean_ksc5601);
Vcharset_korean_ksc5601 =
build_string ("KSC5601 (Korean"),
build_string ("KSC5601 Korean Hangul and Hanja"),
build_string ("ksc5601"),
- Qnil, 0, 0, 0, 33);
+ Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_japanese_jisx0212);
Vcharset_japanese_jisx0212 =
make_charset (LEADING_BYTE_JAPANESE_JISX0212, Qjapanese_jisx0212, 94, 2,
build_string ("JISX0212 (Japanese)"),
build_string ("JISX0212 Japanese Supplement"),
build_string ("jisx0212"),
- Qnil, 0, 0, 0, 33);
+ Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
#define CHINESE_CNS_PLANE_RE(n) "cns11643[.-]\\(.*[.-]\\)?" n "$"
staticpro (&Vcharset_chinese_cns11643_1);
build_string
("CNS 11643 Plane 1 Chinese traditional"),
build_string (CHINESE_CNS_PLANE_RE("1")),
- Qnil, 0, 0, 0, 33);
+ Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_chinese_cns11643_2);
Vcharset_chinese_cns11643_2 =
make_charset (LEADING_BYTE_CHINESE_CNS11643_2, Qchinese_cns11643_2, 94, 2,
build_string
("CNS 11643 Plane 2 Chinese traditional"),
build_string (CHINESE_CNS_PLANE_RE("2")),
- Qnil, 0, 0, 0, 33);
+ Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
#ifdef UTF2000
staticpro (&Vcharset_latin_tcvn5712);
Vcharset_latin_tcvn5712 =
build_string ("TCVN 5712"),
build_string ("TCVN 5712 (VSCII-2)"),
build_string ("Vietnamese TCVN 5712:1983 (VSCII-2)"),
- build_string ("tcvn5712-1"),
- Qnil, 0, 0, 0, 32);
+ build_string ("tcvn5712\\(\\.1993\\)?-1"),
+ Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_latin_viscii_lower);
Vcharset_latin_viscii_lower =
make_charset (LEADING_BYTE_LATIN_VISCII_LOWER, Qlatin_viscii_lower, 96, 1,
build_string ("VISCII lower (Vietnamese)"),
build_string ("VISCII lower (Vietnamese)"),
build_string ("MULEVISCII-LOWER"),
- Qnil, 0, 0, 0, 32);
+ Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_latin_viscii_upper);
Vcharset_latin_viscii_upper =
make_charset (LEADING_BYTE_LATIN_VISCII_UPPER, Qlatin_viscii_upper, 96, 1,
build_string ("VISCII upper (Vietnamese)"),
build_string ("VISCII upper (Vietnamese)"),
build_string ("MULEVISCII-UPPER"),
- Qnil, 0, 0, 0, 32);
+ Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_latin_viscii);
Vcharset_latin_viscii =
make_charset (LEADING_BYTE_LATIN_VISCII, Qlatin_viscii, 256, 1,
build_string ("VISCII 1.1 (Vietnamese)"),
build_string ("VISCII 1.1 (Vietnamese)"),
build_string ("VISCII1\\.1"),
- Qnil, 0, 0, 0, 0);
- staticpro (&Vcharset_ideograph_daikanwa);
- Vcharset_ideograph_daikanwa =
- make_charset (LEADING_BYTE_DAIKANWA, Qideograph_daikanwa, 256, 2,
+ Qnil, 0, 0, 0, 0, Qnil, CONVERSION_IDENTICAL);
+ staticpro (&Vcharset_chinese_big5);
+ Vcharset_chinese_big5 =
+ make_charset (LEADING_BYTE_CHINESE_BIG5, Qchinese_big5, 256, 2,
2, 2, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Daikanwa"),
- build_string ("Morohashi's Daikanwa"),
- build_string ("Daikanwa dictionary by MOROHASHI Tetsuji"),
- build_string ("Daikanwa"),
- Qnil, MIN_CHAR_DAIKANWA, MAX_CHAR_DAIKANWA, 0, 0);
- staticpro (&Vcharset_mojikyo);
- Vcharset_mojikyo =
- make_charset (LEADING_BYTE_MOJIKYO, Qmojikyo, 256, 3,
+ build_string ("Big5"),
+ build_string ("Big5"),
+ build_string ("Big5 Chinese traditional"),
+ build_string ("big5-0"),
+ Qnil,
+ 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,
+ 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+ build_string ("Big5-CDP"),
+ build_string ("Big5 + CDP extension"),
+ build_string ("Big5 with CDP extension"),
+ 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 = \
+ make_charset (LEADING_BYTE_HANZIKU_##n, Qideograph_hanziku_##n, 256, 2, \
+ 2, 2, 0, CHARSET_LEFT_TO_RIGHT, \
+ build_string ("HZK-"#n), \
+ build_string ("HANZIKU-"#n), \
+ build_string ("HANZIKU (pseudo BIG5 encoding) part "#n), \
+ build_string \
+ ("hanziku-"#n"$"), \
+ Qnil, MIN_CHAR_HANZIKU_##n, MAX_CHAR_HANZIKU_##n, \
+ MIN_CHAR_HANZIKU_##n, 0, Qnil, CONVERSION_IDENTICAL);
+ DEF_HANZIKU (1);
+ DEF_HANZIKU (2);
+ DEF_HANZIKU (3);
+ DEF_HANZIKU (4);
+ DEF_HANZIKU (5);
+ DEF_HANZIKU (6);
+ DEF_HANZIKU (7);
+ DEF_HANZIKU (8);
+ DEF_HANZIKU (9);
+ 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 ("Mojikyo"),
- build_string ("Mojikyo"),
- build_string ("Konjaku-Mojikyo"),
+ 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,
+ 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+ build_string ("CB"),
+ build_string ("CBETA"),
+ build_string ("CBETA private characters"),
+ build_string ("cbeta-0"),
+ Qnil, MIN_CHAR_CBETA, MAX_CHAR_CBETA,
+ MIN_CHAR_CBETA, 0, Qnil, CONVERSION_IDENTICAL);
+ staticpro (&Vcharset_ideograph_gt);
+ Vcharset_ideograph_gt =
+ make_charset (LEADING_BYTE_GT, Qideograph_gt, 256, 3,
+ 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+ build_string ("GT"),
+ build_string ("GT"),
+ build_string ("GT"),
build_string (""),
- Qnil, MIN_CHAR_MOJIKYO, MAX_CHAR_MOJIKYO, 0, 0);
- staticpro (&Vcharset_mojikyo_pj_1);
- Vcharset_mojikyo_pj_1 =
- make_charset (LEADING_BYTE_MOJIKYO_PJ_1, Qmojikyo_pj_1, 94, 2,
- 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Mojikyo-PJ-1"),
- build_string ("Mojikyo (pseudo JIS encoding) part 1"),
- build_string
- ("Konjaku-Mojikyo (pseudo JIS encoding) part 1"),
- build_string ("jisx0208\\.Mojikyo-1$"),
- Qnil, 0, 0, 0, 33);
- staticpro (&Vcharset_mojikyo_pj_2);
- Vcharset_mojikyo_pj_2 =
- make_charset (LEADING_BYTE_MOJIKYO_PJ_2, Qmojikyo_pj_2, 94, 2,
- 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Mojikyo-PJ-2"),
- build_string ("Mojikyo (pseudo JIS encoding) part 2"),
- build_string
- ("Konjaku-Mojikyo (pseudo JIS encoding) part 2"),
- build_string ("jisx0208\\.Mojikyo-2$"),
- Qnil, 0, 0, 0, 33);
- staticpro (&Vcharset_mojikyo_pj_3);
- Vcharset_mojikyo_pj_3 =
- make_charset (LEADING_BYTE_MOJIKYO_PJ_3, Qmojikyo_pj_3, 94, 2,
- 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Mojikyo-PJ-3"),
- build_string ("Mojikyo (pseudo JIS encoding) part 3"),
- build_string
- ("Konjaku-Mojikyo (pseudo JIS encoding) part 3"),
- build_string ("jisx0208\\.Mojikyo-3$"),
- Qnil, 0, 0, 0, 33);
- staticpro (&Vcharset_mojikyo_pj_4);
- Vcharset_mojikyo_pj_4 =
- make_charset (LEADING_BYTE_MOJIKYO_PJ_4, Qmojikyo_pj_4, 94, 2,
- 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Mojikyo-PJ-4"),
- build_string ("Mojikyo (pseudo JIS encoding) part 4"),
- build_string
- ("Konjaku-Mojikyo (pseudo JIS encoding) part 4"),
- build_string ("jisx0208\\.Mojikyo-4$"),
- Qnil, 0, 0, 0, 33);
- staticpro (&Vcharset_mojikyo_pj_5);
- Vcharset_mojikyo_pj_5 =
- make_charset (LEADING_BYTE_MOJIKYO_PJ_5, Qmojikyo_pj_5, 94, 2,
- 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Mojikyo-PJ-5"),
- build_string ("Mojikyo (pseudo JIS encoding) part 5"),
- build_string
- ("Konjaku-Mojikyo (pseudo JIS encoding) part 5"),
- build_string ("jisx0208\\.Mojikyo-5$"),
- Qnil, 0, 0, 0, 33);
- staticpro (&Vcharset_mojikyo_pj_6);
- Vcharset_mojikyo_pj_6 =
- make_charset (LEADING_BYTE_MOJIKYO_PJ_6, Qmojikyo_pj_6, 94, 2,
- 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Mojikyo-PJ-6"),
- build_string ("Mojikyo (pseudo JIS encoding) part 6"),
- build_string
- ("Konjaku-Mojikyo (pseudo JIS encoding) part 6"),
- build_string ("jisx0208\\.Mojikyo-6$"),
- Qnil, 0, 0, 0, 33);
- staticpro (&Vcharset_mojikyo_pj_7);
- Vcharset_mojikyo_pj_7 =
- make_charset (LEADING_BYTE_MOJIKYO_PJ_7, Qmojikyo_pj_7, 94, 2,
- 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Mojikyo-PJ-7"),
- build_string ("Mojikyo (pseudo JIS encoding) part 7"),
- build_string
- ("Konjaku-Mojikyo (pseudo JIS encoding) part 7"),
- build_string ("jisx0208\\.Mojikyo-7$"),
- Qnil, 0, 0, 0, 33);
- staticpro (&Vcharset_mojikyo_pj_8);
- Vcharset_mojikyo_pj_8 =
- make_charset (LEADING_BYTE_MOJIKYO_PJ_8, Qmojikyo_pj_8, 94, 2,
- 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Mojikyo-PJ-8"),
- build_string ("Mojikyo (pseudo JIS encoding) part 8"),
- build_string
- ("Konjaku-Mojikyo (pseudo JIS encoding) part 8"),
- build_string ("jisx0208\\.Mojikyo-8$"),
- Qnil, 0, 0, 0, 33);
- staticpro (&Vcharset_mojikyo_pj_9);
- Vcharset_mojikyo_pj_9 =
- make_charset (LEADING_BYTE_MOJIKYO_PJ_9, Qmojikyo_pj_9, 94, 2,
- 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Mojikyo-PJ-9"),
- build_string ("Mojikyo (pseudo JIS encoding) part 9"),
- build_string
- ("Konjaku-Mojikyo (pseudo JIS encoding) part 9"),
- build_string ("jisx0208\\.Mojikyo-9$"),
- Qnil, 0, 0, 0, 33);
- staticpro (&Vcharset_mojikyo_pj_10);
- Vcharset_mojikyo_pj_10 =
- make_charset (LEADING_BYTE_MOJIKYO_PJ_10, Qmojikyo_pj_10, 94, 2,
- 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Mojikyo-PJ-10"),
- build_string ("Mojikyo (pseudo JIS encoding) part 10"),
- build_string
- ("Konjaku-Mojikyo (pseudo JIS encoding) part 10"),
- build_string ("jisx0208\\.Mojikyo-10$"),
- Qnil, 0, 0, 0, 33);
- staticpro (&Vcharset_mojikyo_pj_11);
- Vcharset_mojikyo_pj_11 =
- make_charset (LEADING_BYTE_MOJIKYO_PJ_11, Qmojikyo_pj_11, 94, 2,
- 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Mojikyo-PJ-11"),
- build_string ("Mojikyo (pseudo JIS encoding) part 11"),
- build_string
- ("Konjaku-Mojikyo (pseudo JIS encoding) part 11"),
- build_string ("jisx0208\\.Mojikyo-11$"),
- Qnil, 0, 0, 0, 33);
- staticpro (&Vcharset_mojikyo_pj_12);
- Vcharset_mojikyo_pj_12 =
- make_charset (LEADING_BYTE_MOJIKYO_PJ_12, Qmojikyo_pj_12, 94, 2,
- 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Mojikyo-PJ-12"),
- build_string ("Mojikyo (pseudo JIS encoding) part 12"),
- build_string
- ("Konjaku-Mojikyo (pseudo JIS encoding) part 12"),
- build_string ("jisx0208\\.Mojikyo-12$"),
- Qnil, 0, 0, 0, 33);
- staticpro (&Vcharset_mojikyo_pj_13);
- Vcharset_mojikyo_pj_13 =
- make_charset (LEADING_BYTE_MOJIKYO_PJ_13, Qmojikyo_pj_13, 94, 2,
- 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Mojikyo-PJ-13"),
- build_string ("Mojikyo (pseudo JIS encoding) part 13"),
- build_string
- ("Konjaku-Mojikyo (pseudo JIS encoding) part 13"),
- build_string ("jisx0208\\.Mojikyo-13$"),
- Qnil, 0, 0, 0, 33);
- staticpro (&Vcharset_mojikyo_pj_14);
- Vcharset_mojikyo_pj_14 =
- make_charset (LEADING_BYTE_MOJIKYO_PJ_14, Qmojikyo_pj_14, 94, 2,
- 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Mojikyo-PJ-14"),
- build_string ("Mojikyo (pseudo JIS encoding) part 14"),
- build_string
- ("Konjaku-Mojikyo (pseudo JIS encoding) part 14"),
- build_string ("jisx0208\\.Mojikyo-14$"),
- Qnil, 0, 0, 0, 33);
- staticpro (&Vcharset_mojikyo_pj_15);
- Vcharset_mojikyo_pj_15 =
- make_charset (LEADING_BYTE_MOJIKYO_PJ_15, Qmojikyo_pj_15, 94, 2,
- 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Mojikyo-PJ-15"),
- build_string ("Mojikyo (pseudo JIS encoding) part 15"),
- build_string
- ("Konjaku-Mojikyo (pseudo JIS encoding) part 15"),
- build_string ("jisx0208\\.Mojikyo-15$"),
- Qnil, 0, 0, 0, 33);
- staticpro (&Vcharset_mojikyo_pj_16);
- Vcharset_mojikyo_pj_16 =
- make_charset (LEADING_BYTE_MOJIKYO_PJ_16, Qmojikyo_pj_16, 94, 2,
- 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Mojikyo-PJ-16"),
- build_string ("Mojikyo (pseudo JIS encoding) part 16"),
- build_string
- ("Konjaku-Mojikyo (pseudo JIS encoding) part 16"),
- build_string ("jisx0208\\.Mojikyo-16$"),
- Qnil, 0, 0, 0, 33);
- staticpro (&Vcharset_mojikyo_pj_17);
- Vcharset_mojikyo_pj_17 =
- make_charset (LEADING_BYTE_MOJIKYO_PJ_17, Qmojikyo_pj_17, 94, 2,
- 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Mojikyo-PJ-17"),
- build_string ("Mojikyo (pseudo JIS encoding) part 17"),
- build_string
- ("Konjaku-Mojikyo (pseudo JIS encoding) part 17"),
- build_string ("jisx0208\\.Mojikyo-17$"),
- Qnil, 0, 0, 0, 33);
- staticpro (&Vcharset_mojikyo_pj_18);
- Vcharset_mojikyo_pj_18 =
- make_charset (LEADING_BYTE_MOJIKYO_PJ_18, Qmojikyo_pj_18, 94, 2,
- 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Mojikyo-PJ-18"),
- build_string ("Mojikyo (pseudo JIS encoding) part 18"),
- build_string
- ("Konjaku-Mojikyo (pseudo JIS encoding) part 18"),
- build_string ("jisx0208\\.Mojikyo-18$"),
- Qnil, 0, 0, 0, 33);
- staticpro (&Vcharset_mojikyo_pj_19);
- Vcharset_mojikyo_pj_19 =
- make_charset (LEADING_BYTE_MOJIKYO_PJ_19, Qmojikyo_pj_19, 94, 2,
- 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Mojikyo-PJ-19"),
- build_string ("Mojikyo (pseudo JIS encoding) part 19"),
- build_string
- ("Konjaku-Mojikyo (pseudo JIS encoding) part 19"),
- build_string ("jisx0208\\.Mojikyo-19$"),
- Qnil, 0, 0, 0, 33);
- staticpro (&Vcharset_mojikyo_pj_20);
- Vcharset_mojikyo_pj_20 =
- make_charset (LEADING_BYTE_MOJIKYO_PJ_20, Qmojikyo_pj_20, 94, 2,
- 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Mojikyo-PJ-20"),
- build_string ("Mojikyo (pseudo JIS encoding) part 20"),
+ Qnil, MIN_CHAR_GT, MAX_CHAR_GT,
+ MIN_CHAR_GT, 0, Qnil, CONVERSION_IDENTICAL);
+#define DEF_GT_PJ(n) \
+ staticpro (&Vcharset_ideograph_gt_pj_##n); \
+ Vcharset_ideograph_gt_pj_##n = \
+ make_charset (LEADING_BYTE_GT_PJ_##n, Qideograph_gt_pj_##n, 94, 2, \
+ 2, 0, 0, CHARSET_LEFT_TO_RIGHT, \
+ build_string ("GT-PJ-"#n), \
+ build_string ("GT (pseudo JIS encoding) part "#n), \
+ build_string ("GT 2000 (pseudo JIS encoding) part "#n), \
+ build_string \
+ ("\\(GTpj-"#n "\\|jisx0208\\.GT-"#n "\\)$"), \
+ Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
+ DEF_GT_PJ (1);
+ DEF_GT_PJ (2);
+ DEF_GT_PJ (3);
+ DEF_GT_PJ (4);
+ DEF_GT_PJ (5);
+ DEF_GT_PJ (6);
+ DEF_GT_PJ (7);
+ DEF_GT_PJ (8);
+ DEF_GT_PJ (9);
+ DEF_GT_PJ (10);
+ DEF_GT_PJ (11);
+
+ staticpro (&Vcharset_ideograph_daikanwa_2);
+ Vcharset_ideograph_daikanwa_2 =
+ make_charset (LEADING_BYTE_DAIKANWA_2, Qideograph_daikanwa_2, 256, 2,
+ 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+ build_string ("Daikanwa Rev."),
+ build_string ("Morohashi's Daikanwa Rev."),
build_string
- ("Konjaku-Mojikyo (pseudo JIS encoding) part 20"),
- build_string ("jisx0208\\.Mojikyo-20$"),
- Qnil, 0, 0, 0, 33);
- staticpro (&Vcharset_mojikyo_pj_21);
- Vcharset_mojikyo_pj_21 =
- make_charset (LEADING_BYTE_MOJIKYO_PJ_21, Qmojikyo_pj_21, 94, 2,
- 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("Mojikyo-PJ-21"),
- build_string ("Mojikyo (pseudo JIS encoding) part 21"),
+ ("Daikanwa dictionary (revised version)"),
+ build_string ("Daikanwa\\(\\.[0-9]+\\)?-2"),
+ Qnil, 0, 0, 0, 0, Qnil, CONVERSION_IDENTICAL);
+ staticpro (&Vcharset_ideograph_daikanwa);
+ Vcharset_ideograph_daikanwa =
+ make_charset (LEADING_BYTE_DAIKANWA_3, Qideograph_daikanwa, 256, 2,
+ 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+ build_string ("Daikanwa"),
+ build_string ("Morohashi's Daikanwa Rev.2"),
build_string
- ("Konjaku-Mojikyo (pseudo JIS encoding) part 21"),
- build_string ("jisx0208\\.Mojikyo-21$"),
- Qnil, 0, 0, 0, 33);
+ ("Daikanwa dictionary (second revised version)"),
+ build_string ("Daikanwa\\(\\.[0-9]+\\)?-3"),
+ Qnil, MIN_CHAR_DAIKANWA, MAX_CHAR_DAIKANWA,
+ MIN_CHAR_DAIKANWA, 0, Qnil, CONVERSION_IDENTICAL);
+
staticpro (&Vcharset_ethiopic_ucs);
Vcharset_ethiopic_ucs =
make_charset (LEADING_BYTE_ETHIOPIC_UCS, Qethiopic_ucs, 256, 2,
build_string ("Ethiopic (UCS)"),
build_string ("Ethiopic of UCS"),
build_string ("Ethiopic-Unicode"),
- Qnil, 0x1200, 0x137F, 0x1200, 0);
+ Qnil, 0x1200, 0x137F, 0, 0,
+ Qnil, CONVERSION_IDENTICAL);
#endif
staticpro (&Vcharset_chinese_big5_1);
Vcharset_chinese_big5_1 =
build_string
("Big5 Level-1 Chinese traditional"),
build_string ("big5"),
- Qnil, 0, 0, 0, 33);
+ Qnil, 0, 0, 0, 33, /* Qnil, CONVERSION_IDENTICAL */
+ Vcharset_chinese_big5, CONVERSION_BIG5_1);
staticpro (&Vcharset_chinese_big5_2);
Vcharset_chinese_big5_2 =
make_charset (LEADING_BYTE_CHINESE_BIG5_2, Qchinese_big5_2, 94, 2,
build_string
("Big5 Level-2 Chinese traditional"),
build_string ("big5"),
- Qnil, 0, 0, 0, 33);
+ Qnil, 0, 0, 0, 33, /* Qnil, CONVERSION_IDENTICAL */
+ Vcharset_chinese_big5, CONVERSION_BIG5_2);
#ifdef ENABLE_COMPOSITE_CHARS
/* #### For simplicity, we put composite chars into a 96x96 charset.
projects / chise / xemacs-chise.git- / blobdiff