X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fmule-charset.c;h=91376d7f242574ab819526af348b4e33a1c3d441;hb=864248d400b03a9410f40b1f79991ff9e28aa58e;hp=ad06e2056f32ae25cfb955d3d87039f9d57e74c4;hpb=87578f670075edb2b0e43a07ddc0d0a3c507cae4;p=chise%2Fxemacs-chise.git- diff --git a/src/mule-charset.c b/src/mule-charset.c index ad06e20..91376d7 100644 --- a/src/mule-charset.c +++ b/src/mule-charset.c @@ -423,10 +423,19 @@ put_char_id_table (Emchar ch, Lisp_Object value, Lisp_Object table) Lisp_Object Vcharacter_attribute_table; Lisp_Object Vcharacter_name_table; +Lisp_Object Vcharacter_ideographic_radical_table; +Lisp_Object Vcharacter_ideographic_strokes_table; +Lisp_Object Vcharacter_total_strokes_table; +Lisp_Object Vcharacter_morohashi_daikanwa_table; +Lisp_Object Vcharacter_decomposition_table; Lisp_Object Vcharacter_composition_table; Lisp_Object Vcharacter_variant_table; Lisp_Object Qname; +Lisp_Object Qideographic_radical, Qideographic_strokes; +Lisp_Object Qtotal_strokes; +Lisp_Object Qmorohashi_daikanwa; +Lisp_Object Qideograph_daikanwa; Lisp_Object Q_decomposition; Lisp_Object Qucs; Lisp_Object Q_ucs; @@ -551,9 +560,68 @@ Return the alist of attributes of CHARACTER. */ (character)) { + Lisp_Object alist, ret; + int i; + CHECK_CHAR (character); - return Fcopy_alist (get_char_id_table (XCHAR (character), - Vcharacter_attribute_table)); + alist = Fcopy_alist (get_char_id_table (XCHAR (character), + Vcharacter_attribute_table)); + + ret = get_char_id_table (XCHAR (character), Vcharacter_name_table); + if (!NILP (ret)) + alist = Fcons (Fcons (Qname, ret), alist); + + ret = get_char_id_table (XCHAR (character), + Vcharacter_ideographic_radical_table); + if (!NILP (ret)) + alist = Fcons (Fcons (Qideographic_radical, ret), alist); + + ret = get_char_id_table (XCHAR (character), + Vcharacter_ideographic_strokes_table); + if (!NILP (ret)) + alist = Fcons (Fcons (Qideographic_strokes, ret), alist); + + ret = get_char_id_table (XCHAR (character), Vcharacter_total_strokes_table); + if (!NILP (ret)) + alist = Fcons (Fcons (Qtotal_strokes, ret), alist); + + ret = get_char_id_table (XCHAR (character), + Vcharacter_morohashi_daikanwa_table); + if (!NILP (ret)) + alist = Fcons (Fcons (Qmorohashi_daikanwa, ret), alist); + + ret = get_char_id_table (XCHAR (character), + Vcharacter_decomposition_table); + if (!NILP (ret)) + alist = Fcons (Fcons (Q_decomposition, ret), alist); + + for (i = 0; i < countof (chlook->charset_by_leading_byte); i++) + { + Lisp_Object ccs = chlook->charset_by_leading_byte[i]; + + if (!NILP (ccs)) + { +#if 0 + int code_point = charset_code_point (ccs, XCHAR (character)); + + if (code_point >= 0) + { + alist = Fcons (Fcons (ccs, make_int (code_point)), alist); + } +#else + Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (ccs); + Lisp_Object cpos; + + if ( CHAR_ID_TABLE_P (encoding_table) + && INTP (cpos = get_char_id_table (XCHAR (character), + encoding_table)) ) + { + alist = Fcons (Fcons (ccs, cpos), alist); + } +#endif + } + } + return alist; } DEFUN ("get-char-attribute", Fget_char_attribute, 2, 2, 0, /* @@ -577,6 +645,31 @@ Return the value of CHARACTER's ATTRIBUTE. { return get_char_id_table (XCHAR (character), Vcharacter_name_table); } + else if (EQ (attribute, Qideographic_radical)) + { + return get_char_id_table (XCHAR (character), + Vcharacter_ideographic_radical_table); + } + else if (EQ (attribute, Qideographic_strokes)) + { + return get_char_id_table (XCHAR (character), + Vcharacter_ideographic_strokes_table); + } + else if (EQ (attribute, Qtotal_strokes)) + { + return get_char_id_table (XCHAR (character), + Vcharacter_total_strokes_table); + } + else if (EQ (attribute, Qmorohashi_daikanwa)) + { + return get_char_id_table (XCHAR (character), + Vcharacter_morohashi_daikanwa_table); + } + else if (EQ (attribute, Q_decomposition)) + { + return get_char_id_table (XCHAR (character), + Vcharacter_decomposition_table); + } else { Lisp_Object ret @@ -608,8 +701,38 @@ Store CHARACTER's ATTRIBUTE with VALUE. put_char_id_table (XCHAR (character), value, Vcharacter_name_table); return value; } + else if (EQ (attribute, Qideographic_radical)) + { + CHECK_INT (value); + put_char_id_table (XCHAR (character), value, + Vcharacter_ideographic_radical_table); + return value; + } + else if (EQ (attribute, Qideographic_strokes)) + { + CHECK_INT (value); + put_char_id_table (XCHAR (character), value, + Vcharacter_ideographic_strokes_table); + return value; + } + else if (EQ (attribute, Qtotal_strokes)) + { + CHECK_INT (value); + put_char_id_table (XCHAR (character), value, + Vcharacter_total_strokes_table); + return value; + } + else if (EQ (attribute, Qmorohashi_daikanwa)) + { + CHECK_LIST (value); + put_char_id_table (XCHAR (character), value, + Vcharacter_morohashi_daikanwa_table); + return value; + } else if (EQ (attribute, Q_decomposition)) { + Lisp_Object seq; + if (!CONSP (value)) signal_simple_error ("Invalid value for ->decomposition", value); @@ -618,6 +741,11 @@ Store CHARACTER's ATTRIBUTE with VALUE. { Lisp_Object rest = value; Lisp_Object table = Vcharacter_composition_table; + size_t len; + int i = 0; + + GET_EXTERNAL_LIST_LENGTH (rest, len); + seq = make_older_vector (len, Qnil); while (CONSP (rest)) { @@ -626,6 +754,10 @@ Store CHARACTER's ATTRIBUTE with VALUE. Emchar c = to_char_id (v, "Invalid value for ->decomposition", value); + if (c < 0) + XVECTOR_DATA(seq)[i++] = v; + else + XVECTOR_DATA(seq)[i++] = make_char (c); rest = Fcdr (rest); if (!CONSP (rest)) { @@ -661,7 +793,11 @@ Store CHARACTER's ATTRIBUTE with VALUE. Vcharacter_variant_table); } } + seq = make_older_vector (1, v); } + put_char_id_table (XCHAR (character), seq, + Vcharacter_decomposition_table); + return value; } else if (EQ (attribute, Q_ucs)) { @@ -713,6 +849,34 @@ CHARSET_BYTE_SIZE (Lisp_Charset* cs) #define XCHARSET_BYTE_SIZE(ccs) CHARSET_BYTE_SIZE (XCHARSET (ccs)) +int decoding_table_check_elements (Lisp_Object v, int dim, int ccs_len); +int +decoding_table_check_elements (Lisp_Object v, int dim, int ccs_len) +{ + int i; + + if (XVECTOR_LENGTH (v) > ccs_len) + return -1; + + for (i = 0; i < XVECTOR_LENGTH (v); i++) + { + Lisp_Object c = XVECTOR_DATA(v)[i]; + + if (!NILP (c) && !CHARP (c)) + { + if (VECTORP (c)) + { + int ret = decoding_table_check_elements (c, dim - 1, ccs_len); + if (ret) + return ret; + } + else + return -2; + } + } + return 0; +} + INLINE_HEADER void decoding_table_remove_char (Lisp_Object v, int dim, int byte_offset, int code_point); @@ -935,6 +1099,7 @@ Store character's ATTRIBUTES. Lisp_Object rest = attributes; Lisp_Object code = Fcdr (Fassq (Qucs, attributes)); Lisp_Object character; + Lisp_Object daikanwa = Qnil; if (NILP (code)) { @@ -978,10 +1143,30 @@ Store character's ATTRIBUTES. while (CONSP (rest)) { Lisp_Object cell = Fcar (rest); + Lisp_Object key = Fcar (cell); + Lisp_Object value = Fcdr (cell); if (!LISTP (cell)) signal_simple_error ("Invalid argument", attributes); + + if (EQ (key, Qmorohashi_daikanwa)) + { + size_t len; + GET_EXTERNAL_LIST_LENGTH (value, len); + + if (len == 1) + { + if (NILP (daikanwa)) + daikanwa = Fcdr (Fassq (Qideograph_daikanwa, rest)); + if (EQ (Fcar (value), daikanwa)) + goto ignored; + } + } + else if (EQ (key, Qideograph_daikanwa)) + daikanwa = value; + Fput_char_attribute (character, Fcar (cell), Fcdr (cell)); + ignored: rest = Fcdr (rest); } return @@ -1034,7 +1219,6 @@ Lisp_Object Qascii, Qlatin_viscii_upper, Qvietnamese_viscii_lower, Qvietnamese_viscii_upper, - Qideograph_daikanwa, Qmojikyo, Qmojikyo_pj_1, Qmojikyo_pj_2, @@ -1996,7 +2180,7 @@ add_charset_to_list_mapper (Lisp_Object key, Lisp_Object value, (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; } @@ -2503,11 +2687,8 @@ DEFUN ("set-charset-mapping-table", Fset_charset_mapping_table, 2, 2, 0, /* Set mapping-table of CHARSET to TABLE. */ (charset, table)) -{ /* [tomo] Current implementation does not have complete error - handling mechanism. It seems better to recover encoding/decoding - tables when TABLE is broken. */ +{ struct Lisp_Charset *cs; - /* Lisp_Object old_table; */ size_t i; int byte_offset; @@ -2522,18 +2703,24 @@ Set mapping-table of CHARSET to 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)) @@ -2557,11 +2744,6 @@ Set mapping-table of CHARSET to TABLE. { 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]; @@ -2912,6 +3094,10 @@ syms_of_mule_charset (void) defsymbol (&Qchinese_cns11643_2, "chinese-cns11643-2"); #ifdef UTF2000 defsymbol (&Qname, "name"); + defsymbol (&Qideographic_radical, "ideographic-radical"); + defsymbol (&Qideographic_strokes, "ideographic-strokes"); + defsymbol (&Qtotal_strokes, "total-strokes"); + defsymbol (&Qmorohashi_daikanwa, "morohashi-daikanwa"); defsymbol (&Q_ucs, "->ucs"); defsymbol (&Q_decomposition, "->decomposition"); defsymbol (&Qcompat, "compat"); @@ -3013,7 +3199,7 @@ Leading-code of private TYPE9N charset of column-width 1. #endif #ifdef UTF2000 - Vutf_2000_version = build_string("0.15 (Sangō)"); + Vutf_2000_version = build_string("0.16 (Ōji)"); DEFVAR_LISP ("utf-2000-version", &Vutf_2000_version /* Version number of UTF-2000. */ ); @@ -3024,6 +3210,21 @@ Version number of UTF-2000. staticpro (&Vcharacter_name_table); Vcharacter_name_table = make_char_id_table (Qnil, 0); + /* staticpro (&Vcharacter_ideographic_radical_table); */ + Vcharacter_ideographic_radical_table = make_char_id_table (Qnil, -1); + + /* staticpro (&Vcharacter_ideographic_strokes_table); */ + Vcharacter_ideographic_strokes_table = make_char_id_table (Qnil, -1); + + /* staticpro (&Vcharacter_total_strokes_table); */ + Vcharacter_total_strokes_table = make_char_id_table (Qnil, -1); + + staticpro (&Vcharacter_morohashi_daikanwa_table); + Vcharacter_morohashi_daikanwa_table = make_char_id_table (Qnil, 0); + + /* staticpro (&Vcharacter_decomposition_table); */ + Vcharacter_decomposition_table = make_char_id_table (Qnil, -1); + /* staticpro (&Vcharacter_composition_table); */ Vcharacter_composition_table = make_char_id_table (Qnil, -1);