emacs: src/coding.c comparison

comparison src/coding.c @ 89859:b706c5ee6492

(get_translation_table): New arg max_lookup. Caller changed. (LOOKUP_TRANSLATION_TABLE): Pay attention that table may be a list.

author	Kenichi Handa <handa@m17n.org>
date	Thu, 11 Mar 2004 07:07:41 +0000
parents	23cb9ed79225
children	7160ded23e55

comparison

equal deleted inserted replaced

-:23cb9ed79225
+:b706c5ee6492
 /* Return a translation table (or list of them) from coding system
 attribute vector ATTRS for encoding (ENCODEP is nonzero) or
 decoding (ENCODEP is zero). */
 static Lisp_Object
-get_translation_table (attrs, encodep)
+get_translation_table (attrs, encodep, max_lookup)
+Lisp_Object attrs;
+int encodep, *max_lookup;
 {
 Lisp_Object standard, translation_table;
+Lisp_Object val;
 if (encodep)
 translation_table = CODING_ATTR_ENCODE_TBL (attrs),
 standard = Vstandard_translation_table_for_encode;
 else
 translation_table = CODING_ATTR_DECODE_TBL (attrs),
 standard = Vstandard_translation_table_for_decode;
 if (NILP (translation_table))
-return standard;
+translation_table = standard;
-if (SYMBOLP (translation_table))
+else
-translation_table = Fget (translation_table, Qtranslation_table);
+{
+if (SYMBOLP (translation_table))
+	translation_table = Fget (translation_table, Qtranslation_table);
+else if (CONSP (translation_table))
+	{
+	  translation_table = Fcopy_sequence (translation_table);
+	  for (val = translation_table; CONSP (val); val = XCDR (val))
+	    if (SYMBOLP (XCAR (val)))
+	      XSETCAR (val, Fget (XCAR (val), Qtranslation_table));
+	}
+if (CHAR_TABLE_P (standard))
+	{
+	  if (CONSP (translation_table))
+	    translation_table = nconc2 (translation_table,
+					Fcons (standard, Qnil));
+	  else
+	    translation_table = Fcons (translation_table,
+				       Fcons (standard, Qnil));
+	}
+}
+*max_lookup = 1;
+if (CHAR_TABLE_P (translation_table)
+&& CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (translation_table)) > 1)
+{
+val = XCHAR_TABLE (translation_table)->extras[1];
+if (NATNUMP (val) && *max_lookup < XFASTINT (val))
+	*max_lookup = XFASTINT (val);
+}
 else if (CONSP (translation_table))
 {
-Lisp_Object val;
+Lisp_Object tail, val;
-translation_table = Fcopy_sequence (translation_table);
+for (tail = translation_table; CONSP (tail); tail = XCDR (tail))
-for (val = translation_table; CONSP (val); val = XCDR (val))
+	if (CHAR_TABLE_P (XCAR (tail))
-	if (SYMBOLP (XCAR (val)))
+	    && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (XCAR (tail))) > 1)
-	  XSETCAR (val, Fget (XCAR (val), Qtranslation_table));
+	  {
-}
+	    val = XCHAR_TABLE (XCAR (tail))->extras[1];
-if (! NILP (standard))
+	    if (NATNUMP (val) && *max_lookup < XFASTINT (val))
-{
+	      *max_lookup = XFASTINT (val);
-if (CONSP (translation_table))
+	  }
-	translation_table = nconc2 (translation_table, Fcons (standard, Qnil));
-else
-	translation_table = Fcons (translation_table, Fcons (standard, Qnil));
 }
 return translation_table;
 }
-#define LOOKUP_TRANSLATION_TABLE(table, c, trans)	\
+#define LOOKUP_TRANSLATION_TABLE(table, c, trans)		\
-do {							\
+do {								\
-if (CHAR_TABLE_P (table))				\
+trans = Qnil;						\
-{							\
+if (CHAR_TABLE_P (table))					\
-	trans = CHAR_TABLE_REF (table, c);		\
+{								\
-	if (CHARACTERP (trans))				\
+	trans = CHAR_TABLE_REF (table, c);			\
-	  c = XFASTINT (trans), trans = Qnil;		\
+	if (CHARACTERP (trans))					\
-}							\
+	  c = XFASTINT (trans), trans = Qnil;			\
-else						\
+}								\
-{							\
+else if (CONSP (table))					\
-	Lisp_Object tail = table;			\
+{								\
-							\
+	Lisp_Object tail;					\
-	for (; CONSP (tail); tail = XCDR (tail))	\
+								\
-	  if (CHAR_TABLE_P (XCAR (tail)))		\
+	for (tail = table; CONSP (tail); tail = XCDR (tail))	\
-	    {						\
+	  if (CHAR_TABLE_P (XCAR (tail)))			\
-	      trans = CHAR_TABLE_REF (table, c);	\
+	    {							\
-	      if (CHARACTERP (trans))			\
+	      trans = CHAR_TABLE_REF (XCAR (tail), c);		\
-		c = XFASTINT (trans), trans = Qnil;	\
+	      if (CHARACTERP (trans))				\
-	      else if (! NILP (trans))			\
+		c = XFASTINT (trans), trans = Qnil;		\
-		break;					\
+	      else if (! NILP (trans))				\
-	    }						\
+		break;						\
-}							\
+	    }							\
+}								\
 } while (0)
 static Lisp_Object
 get_translation (val, buf, buf_end, last_block, from_nchars, to_nchars)
 	  if (c >= 0)
 	    {
 	      int from_nchars = 1, to_nchars = 1;
 	      Lisp_Object trans = Qnil;
-	      if (! NILP (translation_table))
+	      LOOKUP_TRANSLATION_TABLE (translation_table, c, trans);
-		LOOKUP_TRANSLATION_TABLE (translation_table, c, trans);
 	      if (! NILP (trans))
 		{
 		  trans = get_translation (trans, buf, buf_end, last_block,
 					   &from_nchars, &to_nchars);
 		  if (EQ (trans, Qt))
 {
 Lisp_Object attrs;
 Lisp_Object undo_list;
 Lisp_Object translation_table;
 int carryover;
+int max_lookup;
 int i;
 if (BUFFERP (coding->src_object)
 && coding->src_pos > 0
 && coding->src_pos < GPT
 coding->errors = 0;
 ALLOC_CONVERSION_WORK_AREA (coding);
 attrs = CODING_ID_ATTRS (coding->id);
-translation_table = get_translation_table (attrs, 0);
+translation_table = get_translation_table (attrs, 0, &max_lookup);
 carryover = 0;
 do
 {
 EMACS_INT pos = coding->dst_pos + coding->produced_char;
 return buf;
 }
 static void
-consume_chars (coding, translation_table)
+consume_chars (coding, translation_table, max_lookup)
 struct coding_system *coding;
 Lisp_Object translation_table;
+int max_lookup;
 {
 int *buf = coding->charbuf;
 int *buf_end = coding->charbuf + coding->charbuf_size;
 const unsigned char *src = coding->source + coding->consumed;
 const unsigned char *src_end = coding->source + coding->src_bytes;
 EMACS_INT end_pos = coding->src_pos + coding->src_chars;
 int multibytep = coding->src_multibyte;
 Lisp_Object eol_type;
 int c;
 EMACS_INT stop, stop_composition, stop_charset;
-int max_lookup = 0, *lookup_buf = NULL;
+int *lookup_buf = NULL;
 if (! NILP (translation_table))
-{
+lookup_buf = alloca (sizeof (int) * max_lookup);
-max_lookup = XINT (XCHAR_TABLE (translation_table)->extras[1]);
-lookup_buf = alloca (sizeof (int) * max_lookup);
-}
 eol_type = CODING_ID_EOL_TYPE (coding->id);
 if (VECTORP (eol_type))
 eol_type = Qunix;
 		c = '\r';
 	    }
 	}
 trans = Qnil;
-if (! NILP (translation_table))
+LOOKUP_TRANSLATION_TABLE (translation_table, c, trans);
-	LOOKUP_TRANSLATION_TABLE (translation_table, c, trans);
 if (NILP (trans))
 	*buf++ = c;
 else
 	{
 	  int from_nchars = 1, to_nchars = 1;
 encode_coding (coding)
 struct coding_system *coding;
 {
 Lisp_Object attrs;
 Lisp_Object translation_table;
+int max_lookup;
 attrs = CODING_ID_ATTRS (coding->id);
-translation_table = get_translation_table (attrs, 1);
+translation_table = get_translation_table (attrs, 1, &max_lookup);
 if (BUFFERP (coding->dst_object))
 {
 set_buffer_internal (XBUFFER (coding->dst_object));
 coding->dst_multibyte
 ALLOC_CONVERSION_WORK_AREA (coding);
 do {
 coding_set_source (coding);
-consume_chars (coding, translation_table);
+consume_chars (coding, translation_table, max_lookup);
 coding_set_destination (coding);
 (*(coding->encoder)) (coding);
 } while (coding->consumed_char < coding->src_chars);
 if (BUFFERP (coding->dst_object))

Mercurial > emacs

comparison src/coding.c @ 89859:b706c5ee6492