From: tomo <tomo>
Date: Sun, 19 Aug 2001 08:08:28 +0000 (+0000)
Subject: (map_over_uint8_byte_table): Change arguments; add new argument `ccs'.
X-Git-Tag: r21-2-41-utf-2000-0_17-2~113
X-Git-Url: http://git.chise.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=bdbf322fda10f6dcfae7d04c81ff0862e41ecc56;p=chise%2Fxemacs-chise.git

(map_over_uint8_byte_table): Change arguments; add new argument `ccs'.
(map_over_uint16_byte_table): Likewise.
(map_over_byte_table): Likewise.
(map_char_id_table): Add new argument `range' like `map_char_table'.
(Fmap_char_attribute): Add new argument `range' like `Fmap_char_table'.
---

diff --git a/src/chartab.c b/src/chartab.c
index 844f570..82fce67 100644
--- a/src/chartab.c
+++ b/src/chartab.c
@@ -230,10 +230,11 @@ uint8_byte_table_same_value_p (Lisp_Object obj)
 }
 
 static int
-map_over_uint8_byte_table (Lisp_Uint8_Byte_Table *ct,
+map_over_uint8_byte_table (Lisp_Uint8_Byte_Table *ct, Emchar ofs, int place,
+			   Lisp_Object ccs,
 			   int (*fn) (struct chartab_range *range,
 				      Lisp_Object val, void *arg),
-			   void *arg, Emchar ofs, int place)
+			   void *arg)
 {
   struct chartab_range rainj;
   int i, retval;
@@ -250,8 +251,11 @@ map_over_uint8_byte_table (Lisp_Uint8_Byte_Table *ct,
 	  c1 = c + unit;
 	  for (; c < c1 && retval == 0; c++)
 	    {
-	      rainj.ch = c;
-	      retval = (fn) (&rainj, UINT8_DECODE (ct->property[i]), arg);
+	      if ( NILP (ccs) || charset_code_point (ccs, c) >= 0 )
+		{
+		  rainj.ch = c;
+		  retval = (fn) (&rainj, UINT8_DECODE (ct->property[i]), arg);
+		}
 	    }
 	}
       else
@@ -454,10 +458,11 @@ uint16_byte_table_same_value_p (Lisp_Object obj)
 }
 
 static int
-map_over_uint16_byte_table (Lisp_Uint16_Byte_Table *ct,
+map_over_uint16_byte_table (Lisp_Uint16_Byte_Table *ct, Emchar ofs, int place,
+			    Lisp_Object ccs,
 			    int (*fn) (struct chartab_range *range,
 				       Lisp_Object val, void *arg),
-			    void *arg, Emchar ofs, int place)
+			    void *arg)
 {
   struct chartab_range rainj;
   int i, retval;
@@ -474,8 +479,12 @@ map_over_uint16_byte_table (Lisp_Uint16_Byte_Table *ct,
 	  c1 = c + unit;
 	  for (; c < c1 && retval == 0; c++)
 	    {
-	      rainj.ch = c;
-	      retval = (fn) (&rainj, UINT16_DECODE (ct->property[i]), arg);
+	      if ( NILP (ccs) || charset_code_point (ccs, c) >= 0 )
+		{
+		  rainj.ch = c;
+		  retval = (fn) (&rainj, UINT16_DECODE (ct->property[i]),
+				 arg);
+		}
 	    }
 	}
       else
@@ -600,10 +609,11 @@ byte_table_same_value_p (Lisp_Object obj)
 }
 
 static int
-map_over_byte_table (Lisp_Byte_Table *ct,
+map_over_byte_table (Lisp_Byte_Table *ct, Emchar ofs, int place,
+		     Lisp_Object ccs,
 		     int (*fn) (struct chartab_range *range,
 				Lisp_Object val, void *arg),
-		     void *arg, Emchar ofs, int place)
+		     void *arg)
 {
   int i, retval;
   Lisp_Object v;
@@ -617,20 +627,20 @@ map_over_byte_table (Lisp_Byte_Table *ct,
 	{
 	  retval
 	    = map_over_uint8_byte_table (XUINT8_BYTE_TABLE(v),
-					 fn, arg, c, place - 1);
+					 c, place - 1, ccs, fn, arg);
 	  c += unit;
 	}
       else if (UINT16_BYTE_TABLE_P (v))
 	{
 	  retval
 	    = map_over_uint16_byte_table (XUINT16_BYTE_TABLE(v),
-					  fn, arg, c, place - 1);
+					  c, place - 1, ccs, fn, arg);
 	  c += unit;
 	}
       else if (BYTE_TABLE_P (v))
 	{
 	  retval = map_over_byte_table (XBYTE_TABLE(v),
-					fn, arg, c, place - 1);
+					c, place - 1, ccs, fn, arg);
 	  c += unit;
 	}
       else if (!UNBOUNDP (v))
@@ -642,8 +652,11 @@ map_over_byte_table (Lisp_Byte_Table *ct,
 
 	  for (; c < c1 && retval == 0; c++)
 	    {
-	      rainj.ch = c;
-	      retval = (fn) (&rainj, v, arg);
+	      if ( NILP (ccs) || charset_code_point (ccs, c) >= 0 )
+		{
+		  rainj.ch = c;
+		  retval = (fn) (&rainj, v, arg);
+		}
 	    }
 	}
       else
@@ -885,38 +898,169 @@ put_char_id_table (Emchar ch, Lisp_Object value, Lisp_Object table)
    becomes the return value of map_char_id_table(). */
 int
 map_char_id_table (Lisp_Char_ID_Table *ct,
+		   struct chartab_range *range,
 		   int (*fn) (struct chartab_range *range,
 			      Lisp_Object val, void *arg),
 		   void *arg);
 int
 map_char_id_table (Lisp_Char_ID_Table *ct,
+		   struct chartab_range *range,
 		   int (*fn) (struct chartab_range *range,
 			      Lisp_Object val, void *arg),
 		   void *arg)
 {
   Lisp_Object v = ct->table;
 
-  if (UINT8_BYTE_TABLE_P (v))
-    return map_over_uint8_byte_table (XUINT8_BYTE_TABLE(v), fn, arg, 0, 3);
-  else if (UINT16_BYTE_TABLE_P (v))
-    return map_over_uint16_byte_table (XUINT16_BYTE_TABLE(v), fn, arg, 0, 3);
-  else if (BYTE_TABLE_P (v))
-    return map_over_byte_table (XBYTE_TABLE(v), fn, arg, 0, 3);
-  else if (!UNBOUNDP (v))
+  switch (range->type)
     {
-      struct chartab_range rainj;
-      int unit = 1 << 24;
-      Emchar c = 0;
-      Emchar c1 = c + unit;
-      int retval;
+    case CHARTAB_RANGE_ALL:
+      if (UINT8_BYTE_TABLE_P (v))
+	return map_over_uint8_byte_table (XUINT8_BYTE_TABLE(v), 0, 3,
+					  Qnil, fn, arg);
+      else if (UINT16_BYTE_TABLE_P (v))
+	return map_over_uint16_byte_table (XUINT16_BYTE_TABLE(v), 0, 3,
+					   Qnil, fn, arg);
+      else if (BYTE_TABLE_P (v))
+	return map_over_byte_table (XBYTE_TABLE(v), 0, 3, Qnil, fn, arg);
+      else if (!UNBOUNDP (v))
+	{
+	  struct chartab_range rainj;
+	  int unit = 1 << 24;
+	  Emchar c = 0;
+	  Emchar c1 = c + unit;
+	  int retval;
 
-      rainj.type = CHARTAB_RANGE_CHAR;
+	  rainj.type = CHARTAB_RANGE_CHAR;
 
-      for (retval = 0; c < c1 && retval == 0; c++)
+	  for (retval = 0; c < c1 && retval == 0; c++)
+	    {
+	      rainj.ch = c;
+	      retval = (fn) (&rainj, v, arg);
+	    }
+	}
+      return 0;
+    case CHARTAB_RANGE_CHARSET:
+      if (UINT8_BYTE_TABLE_P (v))
+	return map_over_uint8_byte_table (XUINT8_BYTE_TABLE(v), 0, 3,
+					  range->charset, fn, arg);
+      else if (UINT16_BYTE_TABLE_P (v))
+	return map_over_uint16_byte_table (XUINT16_BYTE_TABLE(v), 0, 3,
+					   range->charset, fn, arg);
+      else if (BYTE_TABLE_P (v))
+	return map_over_byte_table (XBYTE_TABLE(v), 0, 3,
+				    range->charset, fn, arg);
+      else if (!UNBOUNDP (v))
 	{
-	  rainj.ch = c;
-	  retval = (fn) (&rainj, v, arg);
+	  struct chartab_range rainj;
+	  int unit = 1 << 24;
+	  Emchar c = 0;
+	  Emchar c1 = c + unit;
+	  int retval;
+
+	  rainj.type = CHARTAB_RANGE_CHAR;
+
+	  for (retval = 0; c < c1 && retval == 0; c++)
+	    {
+	      if ( charset_code_point (range->charset, c) >= 0 )
+		{
+		  rainj.ch = c;
+		  retval = (fn) (&rainj, v, arg);
+		}
+	    }
 	}
+      return 0;
+    case CHARTAB_RANGE_ROW:
+      {
+	int cell_min, cell_max, i;
+	int retval;
+	struct chartab_range rainj;
+
+	if (XCHARSET_DIMENSION (range->charset) < 2)
+	  signal_simple_error ("Charset in row vector must be multi-byte",
+			       range->charset);
+	else
+	  {
+	    switch (XCHARSET_CHARS (range->charset))
+	      {
+	      case 94:
+		cell_min = 33; cell_max = 126;
+		break;
+	      case 96:
+		cell_min = 32; cell_max = 127;
+		break;
+	      case 128:
+		cell_min = 0; cell_max = 127;
+		break;
+	      case 256:
+		cell_min = 0; cell_max = 255;
+		break;
+	      default:
+		abort ();
+	      }
+	  }
+	if (XCHARSET_DIMENSION (range->charset) == 2)
+	  check_int_range (range->row, cell_min, cell_max);
+	else if (XCHARSET_DIMENSION (range->charset) == 3)
+	  {
+	    check_int_range (range->row >> 8  , cell_min, cell_max);
+	    check_int_range (range->row & 0xFF, cell_min, cell_max);
+	  }
+	else if (XCHARSET_DIMENSION (range->charset) == 4)
+	  {
+	    check_int_range ( range->row >> 16       , cell_min, cell_max);
+	    check_int_range ((range->row >> 8) & 0xFF, cell_min, cell_max);
+	    check_int_range ( range->row       & 0xFF, cell_min, cell_max);
+	  }
+	else
+	  abort ();
+
+	rainj.type = CHARTAB_RANGE_CHAR;
+	for (retval =0, i = cell_min; i <= cell_max && retval == 0; i++)
+	  {
+	    Emchar ch = DECODE_CHAR (range->charset, (range->row << 8) | i);
+	    Lisp_Object val
+	      = get_byte_table (get_byte_table
+				(get_byte_table
+				 (get_byte_table
+				  (v,
+				   (unsigned char)(ch >> 24)),
+				  (unsigned char) (ch >> 16)),
+				 (unsigned char)  (ch >> 8)),
+				(unsigned char)    ch);
+
+	    if (!UNBOUNDP (val))
+	      {
+		rainj.ch = ch;
+		retval = (fn) (&rainj, val, arg);
+	      }
+	  }
+	return retval;
+      }
+    case CHARTAB_RANGE_CHAR:
+      {
+	Emchar ch = range->ch;
+	Lisp_Object val
+	  = get_byte_table (get_byte_table
+			    (get_byte_table
+			     (get_byte_table
+			      (v,
+			       (unsigned char)(ch >> 24)),
+			      (unsigned char) (ch >> 16)),
+			     (unsigned char)  (ch >> 8)),
+			    (unsigned char)    ch);
+	struct chartab_range rainj;
+
+	if (!UNBOUNDP (val))
+	  {
+	    rainj.type = CHARTAB_RANGE_CHAR;
+	    rainj.ch = ch;
+	    return (fn) (&rainj, val, arg);
+	  }
+	else
+	  return 0;
+      }
+    default:
+      abort ();
     }
   return 0;
 }
@@ -2759,16 +2903,21 @@ Remove CHARACTER's ATTRIBUTE.
   return Qnil;
 }
 
-DEFUN ("map-char-attribute", Fmap_char_attribute, 2, 2, 0, /*
+DEFUN ("map-char-attribute", Fmap_char_attribute, 2, 3, 0, /*
 Map FUNCTION over entries in ATTRIBUTE, calling it with two args,
 each key and value in the table.
+
+RANGE specifies a subrange to map over and is in the same format as
+the RANGE argument to `put-range-table'.  If omitted or t, it defaults to
+the entire table.
 */
-       (function, attribute))
+       (function, attribute, range))
 {
   Lisp_Object ccs;
   Lisp_Char_ID_Table *ct;
   struct slow_map_char_table_arg slarg;
   struct gcpro gcpro1, gcpro2;
+  struct chartab_range rainj;
 
   if (!NILP (ccs = Ffind_charset (attribute)))
     {
@@ -2789,10 +2938,13 @@ each key and value in the table.
       else
 	return Qnil;
     }
+  if (NILP (range))
+    range = Qt;
+  decode_char_table_range (range, &rainj);
   slarg.function = function;
   slarg.retval = Qnil;
   GCPRO2 (slarg.function, slarg.retval);
-  map_char_id_table (ct, slow_map_char_table_fun, &slarg);
+  map_char_id_table (ct, &rainj, slow_map_char_table_fun, &slarg);
   UNGCPRO;
 
   return slarg.retval;