From: Kenichi Handa Date: Wed, 12 Jun 2002 00:13:57 +0000 (+0000) Subject: (load_charset_map): Set the default value of encoder X-Git-Tag: emacs-pretest-23.0.90~8295^2~1864^2~659 X-Git-Url: http://git.eshelyaron.com/gitweb/?a=commitdiff_plain;h=374c5cfd11abede350039bc5879421be51129542;p=emacs.git (load_charset_map): Set the default value of encoder and deunifier char-tables to nil. (map_charset_chars): Argument changed. Callers changed. Use map_char_table_for_charset instead of map_char_table. (Fmap_charset_chars): New optional args from_code and to_code. (Fdefine_charset_internal): Adjusted for the change of `define-charset' (:parents -> :subset or :superset). (charset_work): New variable. (encode_char): Adjusted for the change of Fdefine_charset_internal. (syms_of_charset): Likewise. --- diff --git a/src/charset.c b/src/charset.c index e2ef9b08651..2425e18c58e 100644 --- a/src/charset.c +++ b/src/charset.c @@ -205,13 +205,12 @@ load_charset_map (charset, entries, n_entries, control_flag) if (control_flag > 0) { int n = CODE_POINT_TO_INDEX (charset, max_code) + 1; - unsigned invalid_code = CHARSET_INVALID_CODE (charset); - table = Fmake_char_table (Qnil, make_number (invalid_code)); + table = Fmake_char_table (Qnil, Qnil); if (control_flag == 1) vec = Fmake_vector (make_number (n), make_number (-1)); else if (! CHAR_TABLE_P (Vchar_unify_table)) - Vchar_unify_table = Fmake_char_table (Qnil, make_number (-1)); + Vchar_unify_table = Fmake_char_table (Qnil, Qnil); charset_map_loaded = 1; } @@ -551,26 +550,41 @@ DEFUN ("charsetp", Fcharsetp, Scharsetp, 1, 1, 0, void -map_charset_chars (c_function, function, charset_symbol, arg) - void (*c_function) P_ ((Lisp_Object, Lisp_Object, Lisp_Object)); - Lisp_Object function, charset_symbol, arg; +map_charset_chars (c_function, function, arg, + charset, from, to) + void (*c_function) P_ ((Lisp_Object, Lisp_Object)); + Lisp_Object function, arg; + struct charset *charset; + unsigned from, to; + { - int id; - struct charset *charset; Lisp_Object range; - - CHECK_CHARSET_GET_ID (charset_symbol, id); - charset = CHARSET_FROM_ID (id); + int partial; if (CHARSET_METHOD (charset) == CHARSET_METHOD_MAP_DEFERRED) load_charset (charset); + partial = (from > CHARSET_MIN_CODE (charset) + || to < CHARSET_MAX_CODE (charset)); + + if (CHARSET_UNIFIED_P (charset) + && CHAR_TABLE_P (CHARSET_DEUNIFIER (charset))) + { + map_char_table_for_charset (c_function, function, + CHARSET_DEUNIFIER (charset), arg, + partial ? charset : NULL, from, to); + } + if (CHARSET_METHOD (charset) == CHARSET_METHOD_OFFSET) { - range = Fcons (make_number (CHARSET_MIN_CHAR (charset)), - make_number (CHARSET_MAX_CHAR (charset))); + int from_idx = CODE_POINT_TO_INDEX (charset, from); + int to_idx = CODE_POINT_TO_INDEX (charset, to); + int from_c = from_idx + CHARSET_CODE_OFFSET (charset); + int to_c = to_idx + CHARSET_CODE_OFFSET (charset); + + range = Fcons (make_number (from_c), make_number (to_c)); if (NILP (function)) - (*c_function) (arg, range, Qnil); + (*c_function) (range, arg); else call2 (function, range, arg); } @@ -578,86 +592,87 @@ map_charset_chars (c_function, function, charset_symbol, arg) { if (! CHAR_TABLE_P (CHARSET_ENCODER (charset))) return; - if (CHARSET_ASCII_COMPATIBLE_P (charset)) + if (CHARSET_ASCII_COMPATIBLE_P (charset) && from <= 127) { - range = Fcons (make_number (0), make_number (127)); + range = Fcons (make_number (from), make_number (to)); + if (to >= 128) + XSETCAR (range, make_number (127)); + if (NILP (function)) - (*c_function) (arg, range, Qnil); + (*c_function) (range, arg); else call2 (function, range, arg); } - map_char_table (c_function, function, CHARSET_ENCODER (charset), arg, - 0, NULL); + map_char_table_for_charset (c_function, function, + CHARSET_ENCODER (charset), arg, + partial ? charset : NULL, from, to); } - else /* i.e. CHARSET_METHOD_PARENT */ + else if (CHARSET_METHOD (charset) == CHARSET_METHOD_SUBSET) { - int from, to, c; - unsigned code; - int i, j, k, l; - int *code_space = CHARSET_CODE_SPACE (charset); - Lisp_Object val; + Lisp_Object subset_info; + int offset; + + subset_info = CHARSET_SUBSET (charset); + charset = CHARSET_FROM_ID (XFASTINT (AREF (subset_info, 0))); + offset = XINT (AREF (subset_info, 3)); + from -= offset; + if (from < XFASTINT (AREF (subset_info, 1))) + from = XFASTINT (AREF (subset_info, 1)); + to -= offset; + if (to > XFASTINT (AREF (subset_info, 2))) + to = XFASTINT (AREF (subset_info, 2)); + map_charset_chars (c_function, function, arg, charset, from, to); + } + else /* i.e. CHARSET_METHOD_SUPERSET */ + { + Lisp_Object parents; - range = Fcons (Qnil, Qnil); - from = to = -2; - for (i = code_space[12]; i <= code_space[13]; i++) - for (j = code_space[8]; j <= code_space[9]; j++) - for (k = code_space[4]; k <= code_space[5]; k++) - for (l = code_space[0]; l <= code_space[1]; l++) - { - code = (i << 24) | (j << 16) | (k << 8) | l; - c = DECODE_CHAR (charset, code); - if (c == to + 1) - { - to++; - continue; - } - if (from >= 0) - { - if (from < to) - { - XSETCAR (range, make_number (from)); - XSETCDR (range, make_number (to)); - val = range; - } - else - val = make_number (from); - if (NILP (function)) - (*c_function) (arg, val, Qnil); - else - call2 (function, val, arg); - } - from = to = (c < 0 ? -2 : c); - } - if (from >= 0) + for (parents = CHARSET_SUPERSET (charset); CONSP (parents); + parents = XCDR (parents)) { - if (from < to) - { - XSETCAR (range, make_number (from)); - XSETCDR (range, make_number (to)); - val = range; - } - else - val = make_number (from); - if (NILP (function)) - (*c_function) (arg, val, Qnil); - else - call2 (function, val, arg); + int offset; + unsigned this_from, this_to; + + charset = CHARSET_FROM_ID (XFASTINT (XCAR (XCAR (parents)))); + offset = XINT (XCDR (XCAR (parents))); + this_from = from - offset; + this_to = to - offset; + if (this_from < CHARSET_MIN_CODE (charset)) + this_from = CHARSET_MIN_CODE (charset); + if (this_to > CHARSET_MAX_CODE (charset)) + this_to = CHARSET_MAX_CODE (charset); + map_charset_chars (c_function, function, arg, charset, from, to); } } } -DEFUN ("map-charset-chars", Fmap_charset_chars, Smap_charset_chars, 2, 3, 0, + +DEFUN ("map-charset-chars", Fmap_charset_chars, Smap_charset_chars, 2, 5, 0, doc: /* Call FUNCTION for all characters in CHARSET. -FUNCTION is called with an argument RANGE and optional 2nd +FUNCTION is called with an argument RANGE and the optional 3rd argument ARG. -RANGE is either a cons (FROM . TO), where FROM and TO indicate a range of -characters contained in CHARSET or a single character in the case that -FROM and TO would be equal. (The charset mapping may have gaps.)*/) - (function, charset, arg) - Lisp_Object function, charset, arg; +RANGE is a cons (FROM . TO), where FROM and TO indicate a range of +characters contained in CHARSET. + +The optional 4th and 5th arguments FROM-CODE and TO-CODE specify the +range of code points of targer characters. */) + (function, charset, arg, from_code, to_code) + Lisp_Object function, charset, arg, from_code, to_code; { - map_charset_chars (NULL, function, charset, arg); + struct charset *cs; + + CHECK_CHARSET_GET_CHARSET (charset, cs); + if (NILP (from_code)) + from_code = 0; + if (from_code < CHARSET_MIN_CODE (cs)) + from_code = CHARSET_MIN_CODE (cs); + if (NILP (to_code)) + to_code = 0xFFFFFFFF; + if (to_code > CHARSET_MAX_CODE (cs)) + to_code = CHARSET_MAX_CODE (cs); + + map_charset_chars (NULL, function, arg, cs, from_code, to_code); return Qnil; } @@ -893,13 +908,45 @@ usage: (define-charset-internal ...) */) load_charset_map_from_vector (&charset, val, 0); charset.method = CHARSET_METHOD_MAP_DEFERRED; } - else if (! NILP (args[charset_arg_parents])) + else if (! NILP (args[charset_arg_subset])) { - val = args[charset_arg_parents]; - CHECK_LIST (val); - charset.method = CHARSET_METHOD_INHERIT; + Lisp_Object parent; + Lisp_Object parent_min_code, parent_max_code, parent_code_offset; + struct charset *parent_charset; + + val = args[charset_arg_subset]; + parent = Fcar (val); + CHECK_CHARSET_GET_CHARSET (parent, parent_charset); + parent_min_code = Fnth (make_number (1), val); + CHECK_NATNUM (parent_min_code); + parent_max_code = Fnth (make_number (2), val); + CHECK_NATNUM (parent_max_code); + parent_code_offset = Fnth (make_number (3), val); + CHECK_NUMBER (parent_code_offset); + val = Fmake_vector (make_number (4), Qnil); + ASET (val, 0, make_number (parent_charset->id)); + ASET (val, 1, parent_min_code); + ASET (val, 2, parent_max_code); + ASET (val, 3, parent_code_offset); + ASET (attrs, charset_subset, val); + + charset.method = CHARSET_METHOD_SUBSET; + /* Here, we just copy the parent's fast_map. It's not accurate, + but at least it works for quickly detecting which character + DOESN'T belong to this charset. */ + for (i = 0; i < 190; i++) + charset.fast_map[i] = parent_charset->fast_map[i]; + + /* We also copy these for parents. */ + charset.min_char = parent_charset->min_char; + charset.max_char = parent_charset->max_char; + } + else if (! NILP (args[charset_arg_superset])) + { + val = args[charset_arg_superset]; + charset.method = CHARSET_METHOD_SUPERSET; val = Fcopy_sequence (val); - ASET (attrs, charset_parents, val); + ASET (attrs, charset_superset, val); charset.min_char = MAX_CHAR; charset.max_char = 0; @@ -1351,17 +1398,30 @@ decode_char (charset, code) method = CHARSET_METHOD (charset); } - if (method == CHARSET_METHOD_INHERIT) + if (method == CHARSET_METHOD_SUBSET) + { + Lisp_Object subset_info; + + subset_info = CHARSET_SUBSET (charset); + charset = CHARSET_FROM_ID (XFASTINT (AREF (subset_info, 0))); + code -= XINT (AREF (subset_info, 3)); + if (code < XFASTINT (AREF (subset_info, 1)) + || code > XFASTINT (AREF (subset_info, 2))) + c = -1; + else + c = DECODE_CHAR (charset, code); + } + else if (method == CHARSET_METHOD_SUPERSET) { Lisp_Object parents; - parents = CHARSET_PARENTS (charset); + parents = CHARSET_SUPERSET (charset); c = -1; for (; CONSP (parents); parents = XCDR (parents)) { int id = XINT (XCAR (XCAR (parents))); int code_offset = XINT (XCDR (XCAR (parents))); - unsigned this_code = code + code_offset; + unsigned this_code = code - code_offset; charset = CHARSET_FROM_ID (id); if ((c = DECODE_CHAR (charset, this_code)) >= 0) @@ -1398,6 +1458,8 @@ decode_char (charset, code) return c; } +/* Variable used temporarily by the macro ENCODE_CHAR. */ +Lisp_Object charset_work; /* Return a code-point of CHAR in CHARSET. If CHAR doesn't belong to CHARSET, return CHARSET_INVALID_CODE (CHARSET). */ @@ -1412,8 +1474,7 @@ encode_char (charset, c) if (CHARSET_UNIFIED_P (charset)) { - Lisp_Object deunifier; - int deunified; + Lisp_Object deunifier, deunified; deunifier = CHARSET_DEUNIFIER (charset); if (! CHAR_TABLE_P (deunifier)) @@ -1421,20 +1482,36 @@ encode_char (charset, c) Funify_charset (CHARSET_NAME (charset), Qnil); deunifier = CHARSET_DEUNIFIER (charset); } - deunified = XINT (CHAR_TABLE_REF (deunifier, c)); - if (deunified > 0) - c = deunified; + deunified = CHAR_TABLE_REF (deunifier, c); + if (! NILP (deunified)) + c = XINT (deunified); } if (! CHARSET_FAST_MAP_REF ((c), charset->fast_map) || c < CHARSET_MIN_CHAR (charset) || c > CHARSET_MAX_CHAR (charset)) return CHARSET_INVALID_CODE (charset); - if (method == CHARSET_METHOD_INHERIT) + if (method == CHARSET_METHOD_SUBSET) + { + Lisp_Object subset_info; + struct charset *this_charset; + + subset_info = CHARSET_SUBSET (charset); + this_charset = CHARSET_FROM_ID (XFASTINT (AREF (subset_info, 0))); + code = ENCODE_CHAR (this_charset, c); + if (code == CHARSET_INVALID_CODE (this_charset) + || code < XFASTINT (AREF (subset_info, 1)) + || code > XFASTINT (AREF (subset_info, 2))) + return CHARSET_INVALID_CODE (charset); + code += XINT (AREF (subset_info, 3)); + return code; + } + + if (method == CHARSET_METHOD_SUPERSET) { Lisp_Object parents; - parents = CHARSET_PARENTS (charset); + parents = CHARSET_SUPERSET (charset); for (; CONSP (parents); parents = XCDR (parents)) { int id = XINT (XCAR (XCAR (parents))); @@ -1445,7 +1522,7 @@ encode_char (charset, c) if (code != CHARSET_INVALID_CODE (this_charset) && (code_offset < 0 || code >= code_offset)) { - code -= code_offset; + code += code_offset; if (code >= charset->min_code && code <= charset->max_code && CODE_POINT_TO_INDEX (charset, code) >= 0) return code; @@ -1469,6 +1546,8 @@ encode_char (charset, c) if (! CHAR_TABLE_P (CHARSET_ENCODER (charset))) return CHARSET_INVALID_CODE (charset); val = CHAR_TABLE_REF (encoder, c); + if (NILP (val)) + return CHARSET_INVALID_CODE (charset); code = XINT (val); if (! CHARSET_COMPACT_CODES_P (charset)) code = INDEX_TO_CODE_POINT (charset, code); @@ -1962,7 +2041,8 @@ The default value is sub-directory "charsets" of `data-directory'. */); args[charset_arg_invalid_code] = Qnil; args[charset_arg_code_offset] = make_number (0); args[charset_arg_map] = Qnil; - args[charset_arg_parents] = Qnil; + args[charset_arg_subset] = Qnil; + args[charset_arg_superset] = Qnil; args[charset_arg_unify_map] = Qnil; /* The actual plist is set by mule-conf.el. */ plist[1] = args[charset_arg_name]; @@ -1993,7 +2073,8 @@ The default value is sub-directory "charsets" of `data-directory'. */); args[charset_arg_invalid_code] = Qnil; args[charset_arg_code_offset] = make_number (0); args[charset_arg_map] = Qnil; - args[charset_arg_parents] = Qnil; + args[charset_arg_subset] = Qnil; + args[charset_arg_superset] = Qnil; args[charset_arg_unify_map] = Qnil; /* The actual plist is set by mule-conf.el. */ plist[1] = args[charset_arg_name];