emacs: src/charset.c comparison

comparison src/charset.c @ 88745:f247f70ed2c3

(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.

author	Kenichi Handa <handa@m17n.org>
date	Wed, 12 Jun 2002 00:13:57 +0000
parents	8646a672489b
children	c2d4566b3cde

comparison

equal deleted inserted replaced

-:5b9a72e491d4
+:f247f70ed2c3
 return;
 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, Qnil);
-table = Fmake_char_table (Qnil, make_number (invalid_code));
 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;
 }
 min_char = max_char = entries->entry[0].c;
 return (CHARSETP (object) ? Qt : Qnil);
 }
 void
-map_charset_chars (c_function, function, charset_symbol, arg)
+map_charset_chars (c_function, function, arg,
-void (*c_function) P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
+		   charset, from, to)
-Lisp_Object function, charset_symbol, arg;
+void (*c_function) P_ ((Lisp_Object, Lisp_Object));
-{
+Lisp_Object function, arg;
-int id;
+struct charset *charset;
-struct charset *charset;
+unsigned from, to;
+{
 Lisp_Object range;
+int partial;
-CHECK_CHARSET_GET_ID (charset_symbol, id);
-charset = CHARSET_FROM_ID (id);
 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)),
+int from_idx = CODE_POINT_TO_INDEX (charset, from);
-		     make_number (CHARSET_MAX_CHAR (charset)));
+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);
 }
 else if (CHARSET_METHOD (charset) == CHARSET_METHOD_MAP)
 {
 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,
+map_char_table_for_charset (c_function, function,
-		      0, NULL);
+				  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;
+Lisp_Object subset_info;
-int i, j, k, l;
+int offset;
-int *code_space = CHARSET_CODE_SPACE (charset);
-Lisp_Object val;
+subset_info = CHARSET_SUBSET (charset);
+charset = CHARSET_FROM_ID (XFASTINT (AREF (subset_info, 0)));
-range = Fcons (Qnil, Qnil);
+offset = XINT (AREF (subset_info, 3));
-from = to = -2;
+from -= offset;
-for (i = code_space[12]; i <= code_space[13]; i++)
+if (from < XFASTINT (AREF (subset_info, 1)))
-	for (j = code_space[8]; j <= code_space[9]; j++)
+	from = XFASTINT (AREF (subset_info, 1));
-	  for (k = code_space[4]; k <= code_space[5]; k++)
+to -= offset;
-	    for (l = code_space[0]; l <= code_space[1]; l++)
+if (to > XFASTINT (AREF (subset_info, 2)))
-	      {
+	to = XFASTINT (AREF (subset_info, 2));
-		code = (i << 24) | (j << 16) | (k << 8) | l;
+map_charset_chars (c_function, function, arg, charset, from, to);
-		c = DECODE_CHAR (charset, code);
+}
-		if (c == to + 1)
+else				/* i.e. CHARSET_METHOD_SUPERSET */
-		  {
+{
-		    to++;
+Lisp_Object parents;
-		    continue;
-		  }
+for (parents = CHARSET_SUPERSET (charset); CONSP (parents);
-		if (from >= 0)
+	   parents = XCDR (parents))
-		  {
+	{
-		    if (from < to)
+	  int offset;
-		      {
+	  unsigned this_from, this_to;
-			XSETCAR (range, make_number (from));
-			XSETCDR (range, make_number (to));
+	  charset = CHARSET_FROM_ID (XFASTINT (XCAR (XCAR (parents))));
-			val = range;
+	  offset = XINT (XCDR (XCAR (parents)));
-		      }
+	  this_from = from - offset;
-		    else
+	  this_to = to - offset;
-		      val = make_number (from);
+	  if (this_from < CHARSET_MIN_CODE (charset))
-		    if (NILP (function))
+	    this_from = CHARSET_MIN_CODE (charset);
-		      (*c_function) (arg, val, Qnil);
+	  if (this_to > CHARSET_MAX_CODE (charset))
-		    else
+	    this_to = CHARSET_MAX_CODE (charset);
-		      call2 (function, val, arg);
+	  map_charset_chars (c_function, function, arg, charset, from, to);
-		  }
-		from = to = (c < 0 ? -2 : c);
-	      }
-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);
 	}
 }
 }
-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
+RANGE is a cons (FROM .  TO), where FROM and TO indicate a range of
-characters contained in CHARSET or a single character in the case that
+characters contained in CHARSET.
-FROM and TO would be equal.  (The charset mapping may have gaps.)*/)
-(function, charset, arg)
+The optional 4th and 5th arguments FROM-CODE and TO-CODE specify the
-Lisp_Object function, charset, arg;
+range of code points of targer characters.  */)
-{
+(function, charset, arg, from_code, to_code)
-map_charset_chars (NULL, function, charset, arg);
+Lisp_Object function, charset, arg, from_code, to_code;
+{
+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;
 }
 /* Define a charset according to the arguments.  The Nth argument is
 	load_charset_map_from_file (&charset, val, 0);
 else
 	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];
+Lisp_Object parent;
-CHECK_LIST (val);
+Lisp_Object parent_min_code, parent_max_code, parent_code_offset;
-charset.method = CHARSET_METHOD_INHERIT;
+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;
 for (; ! NILP (val); val = Fcdr (val))
 	{
 {
 load_charset (charset);
 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)
 	    break;
 	}
 }
 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).  */
 unsigned
 unsigned code;
 enum charset_method method = CHARSET_METHOD (charset);
 if (CHARSET_UNIFIED_P (charset))
 {
-Lisp_Object deunifier;
+Lisp_Object deunifier, deunified;
-int deunified;
 deunifier = CHARSET_DEUNIFIER (charset);
 if (! CHAR_TABLE_P (deunifier))
 	{
 	  Funify_charset (CHARSET_NAME (charset), Qnil);
 	  deunifier = CHARSET_DEUNIFIER (charset);
 	}
-deunified = XINT (CHAR_TABLE_REF (deunifier, c));
+deunified = CHAR_TABLE_REF (deunifier, c);
-if (deunified > 0)
+if (! NILP (deunified))
-	c = 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)));
 	  int code_offset = XINT (XCDR (XCAR (parents)));
 	  struct charset *this_charset = CHARSET_FROM_ID (id);
 	  code = ENCODE_CHAR (this_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;
 	    }
 	}
 encoder = CHARSET_ENCODER (charset);
 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);
 }
 else				/* method == CHARSET_METHOD_OFFSET */
 args[charset_arg_ascii_compatible_p] = Qt;
 args[charset_arg_supplementary_p] = Qnil;
 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];
 plist[3] = args[charset_arg_dimension];
 plist[5] = args[charset_arg_code_space];
 args[charset_arg_ascii_compatible_p] = Qt;
 args[charset_arg_supplementary_p] = Qnil;
 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];
 plist[3] = args[charset_arg_dimension];
 plist[5] = args[charset_arg_code_space];

Mercurial > emacs

comparison src/charset.c @ 88745:f247f70ed2c3