Include charset.h and coding.h.

(TS_end_italic_mode, TS_italic_mode, TS_bold_mode): New variables.
(TS_end_bold_mode, TS_end_underscore_mode): New variables.
(TS_underscore_mode): New variable.
(encode_terminal_code): New function.
(write_glyphs, insert_glyphs): Perform character code conversion
on output to a terminal.
(term_init): Initialize TS_bold_mode, TS_end_bold_mode,
TS_end_underscore_mode, and TS_underscore_mode.

1 files changed, 139 insertions, 43 deletions

diff --git a/src/term.c b/src/term.c
index ce771533b6f..0042da83600 100644
--- a/src/term.c
+++ b/src/term.c
@@ -27,6 +27,8 @@ Boston, MA 02111-1307, USA.  */
 #include "cm.h"
 #undef NULL
 #include "lisp.h"
+#include "charset.h"
+#include "coding.h"
 #include "frame.h"
 #include "disptab.h"
 #include "termhooks.h"
@@ -196,7 +198,9 @@ void (*judge_scroll_bars_hook)( /* FRAME_PTR *FRAME */ );
 
 /* Strings, numbers and flags taken from the termcap entry.  */
 
-char *TS_ins_line;		/* termcap "al" */
+char *TS_end_italic_mode;	/* termcal "ae" */
+char *TS_ins_line;		/* "al" */
+char *TS_italic_mode;		/* "as" */
 char *TS_ins_multi_lines;	/* "AL" (one parameter, # lines to insert) */
 char *TS_bell;			/* "bl" */
 char *TS_clr_to_bottom;		/* "cd" */
@@ -219,6 +223,8 @@ char *TS_insert_mode;		/* "im", enter character-insert mode */
 char *TS_pad_inserted_char;	/* "ip".  Just padding, no commands.  */
 char *TS_end_keypad_mode;	/* "ke" */
 char *TS_keypad_mode;		/* "ks" */
+char *TS_bold_mode;		/* "md" */
+char *TS_end_bold_mode;		/* "me" */
 char *TS_pad_char;		/* "pc", char to use as padding */
 char *TS_repeat;		/* "rp" (2 params, # times to repeat
 				   and character to be repeated) */
@@ -228,6 +234,8 @@ char *TS_standout_mode;		/* "so" */
 char *TS_rev_scroll;		/* "sr" */
 char *TS_end_termcap_modes;	/* "te" */
 char *TS_termcap_modes;		/* "ti" */
+char *TS_end_underscore_mode;	/* "ue" */
+char *TS_underscore_mode;	/* "us" */
 char *TS_visible_bell;		/* "vb" */
 char *TS_end_visual_mode;	/* "ve" */
 char *TS_visual_mode;		/* "vi" */
@@ -760,6 +768,74 @@ clear_end_of_line_raw (first_unused_hpos)
     }
 }
 
+/* Encode SRC_LEN glyphs starting at SRC to terminal output codes and
+   store them at DST.  Do not write more than DST_LEN bytes.  That may
+   require stopping before all SRC_LEN input glyphs have been
+   converted.
+
+   We store the number of glyphs actually converted in *CONSUMED.  The
+   return value is the number of bytes store in DST.  */
+
+int
+encode_terminal_code (src, dst, src_len, dst_len, consumed)
+     GLYPH *src;
+     int src_len;
+     unsigned char *dst;
+     int dst_len, *consumed;
+{
+  GLYPH *src_start = src, *src_end = src + src_len;
+  unsigned char *dst_start = dst, *dst_end = dst + dst_len;
+  register GLYPH g = *src;
+  int c = GLYPH_CHAR (selected_frame, g);
+  unsigned char workbuf[4], *buf;
+  int len, produced, processed;
+  register int tlen = GLYPH_TABLE_LENGTH;
+  register Lisp_Object *tbase = GLYPH_TABLE_BASE;
+
+  while (src < src_end)
+    {
+      g = *src;
+      /* We must skip glyphs to be padded for a wide character.  */
+      if (! (g & GLYPH_MASK_PADDING))
+	{
+	  c = GLYPH_CHAR (selected_frame, g);
+	  if (COMPOSITE_CHAR_P (c))
+	    {
+	      /* If C is a composite character, we can display
+		 only the first component.  */
+	      g = cmpchar_table[COMPOSITE_CHAR_ID (c)]->glyph[0],
+	      c = GLYPH_CHAR (selected_frame, g);
+	    }
+	  if (c < tlen)
+	    {
+	      /* G has an entry in Vglyph_table,
+		 so process any alias before testing for simpleness.  */
+	      GLYPH_FOLLOW_ALIASES (tbase, tlen, g);
+	      c = GLYPH_CHAR (selected_frame, g);
+	    }
+	  if (GLYPH_SIMPLE_P (tbase, tlen, g))
+	    /* We set the multi-byte form of C at BUF.  */
+	    len = CHAR_STRING (c, workbuf, buf);
+	  else
+	    /* We have the multi-byte form in Vglyph_table.  */
+	    len = GLYPH_LENGTH (tbase, g), buf = GLYPH_STRING (tbase, g);
+	  
+	  produced = encode_coding (&terminal_coding, buf, dst,
+				     len, dst_end - dst, &processed);
+	  if (processed < len)
+	    /* We get a carryover because the remaining output
+	       buffer is too short.  We must break the loop here
+	       without increasing SRC so that the next call of
+	       this function start from the same glyph.  */
+	    break;
+	  dst += produced;
+	}
+      src++;
+    }
+  *consumed = src - src_start;
+  return (dst - dst_start);
+}
+
 
 write_glyphs (string, len)
      register GLYPH *string;
@@ -768,6 +844,7 @@ write_glyphs (string, len)
   register GLYPH g;
   register int tlen = GLYPH_TABLE_LENGTH;
   register Lisp_Object *tbase = GLYPH_TABLE_BASE;
+  int produced, consumed;
 
   if (write_glyphs_hook
       && ! FRAME_TERMCAP_P ((updating_frame ? updating_frame : selected_frame)))
@@ -787,42 +864,42 @@ write_glyphs (string, len)
       && (curX + len - (chars_wasted[curY] & 077)
 	  == FRAME_WIDTH (selected_frame)))
     len --;
+  if (len <= 0)
+    return;
 
   cmplus (len);
-  while (--len >= 0)
+  /* The field `last_block' should be set to 1 only at the tail.  */
+  terminal_coding.last_block = 0;
+  while (len > 0)
     {
-      g = *string++;
-      /* Check quickly for G beyond length of table.
-	 That implies it isn't an alias and is simple.  */
-      if (g >= tlen)
+      /* We use shared conversion buffer of the current size (1024
+	 bytes at least).  Usually it is sufficient, but if not, we
+	 just repeat the loop.  */
+      produced = encode_terminal_code (string, conversion_buffer,
+				       len, conversion_buffer_size, &consumed);
+      if (produced > 0)
 	{
-	simple:
-	  putc (g & 0xff, stdout);
+	  fwrite (conversion_buffer, 1, produced, stdout);
 	  if (ferror (stdout))
 	    clearerr (stdout);
 	  if (termscript)
-	    putc (g & 0xff, termscript);
-	}
-      else
-	{
-	  /* G has an entry in Vglyph_table,
-	     so process any alias and then test for simpleness.  */
-	  while (GLYPH_ALIAS_P (tbase, tlen, g))
-	    g = GLYPH_ALIAS (tbase, g);
-	  if (GLYPH_SIMPLE_P (tbase, tlen, g))
-	    goto simple;
-	  else
-	    {
-	      /* Here if G (or its definition as an alias) is not simple.  */
-	      fwrite (GLYPH_STRING (tbase, g), 1, GLYPH_LENGTH (tbase, g),
-		      stdout);
-	      if (ferror (stdout))
-		clearerr (stdout);
-	      if (termscript)
-		fwrite (GLYPH_STRING (tbase, g), 1, GLYPH_LENGTH (tbase, g),
-			termscript);
-	    }
+	    fwrite (conversion_buffer, 1, produced, termscript);
 	}
+      len -= consumed;
+      string += consumed;
+    }
+  /* We may have to output some codes to terminate the writing.  */
+  terminal_coding.last_block = 1;
+  produced = encode_coding (&terminal_coding, (char *)0, conversion_buffer,
+			    0, conversion_buffer_size,
+			    &consumed);
+  if (produced > 0)
+    {
+      fwrite (conversion_buffer, 1, produced, stdout);
+      if (ferror (stdout))
+	clearerr (stdout);
+      if (termscript)
+	fwrite (conversion_buffer, 1, produced, termscript);
     }
   cmcheckmagic ();
 }
@@ -834,10 +911,13 @@ insert_glyphs (start, len)
      register int len;
 {
   char *buf;
-  register GLYPH g;
+  GLYPH g;
   register int tlen = GLYPH_TABLE_LENGTH;
   register Lisp_Object *tbase = GLYPH_TABLE_BASE;
 
+  if (len <= 0)
+    return;
+
   if (insert_glyphs_hook && ! FRAME_TERMCAP_P (updating_frame))
     {
       (*insert_glyphs_hook) (start, len);
@@ -857,30 +937,42 @@ insert_glyphs (start, len)
 
   turn_on_insert ();
   cmplus (len);
-  while (--len >= 0)
+  /* The field `last_block' should be set to 1 only at the tail.  */
+  terminal_coding.last_block = 0;
+  while (len > 0)
     {
+      int produced, consumed;
+
       OUTPUT1_IF (TS_ins_char);
       if (!start)
 	g = SPACEGLYPH;
       else
-	g = *start++;
-
-      if (GLYPH_SIMPLE_P (tbase, tlen, g))
 	{
-	  putc (g & 0xff, stdout);
-	  if (ferror (stdout))
-	    clearerr (stdout);
-	  if (termscript)
-	    putc (g & 0xff, termscript);
+	  g = *start++;
+	  /* We must open sufficient space for a character which
+	     occupies more than one column.  */
+	  while (*start && GLYPH_MASK_PADDING)
+	    {
+	      OUTPUT1_IF (TS_ins_char);
+	      start++, len--;
+	    }
 	}
-      else
+
+      if (len <= 0)
+	/* This is the last glyph.  */
+	terminal_coding.last_block = 1;
+
+      /* We use shared conversion buffer of the current size (1024
+	 bytes at least).  It is surely sufficient for just one glyph.  */
+      produced = encode_terminal_code (&g, conversion_buffer,
+				       1, conversion_buffer_size, &consumed);
+      if (produced > 0)
 	{
-	  fwrite (GLYPH_STRING (tbase, g), 1, GLYPH_LENGTH (tbase, g), stdout);
+	  fwrite (conversion_buffer, 1, produced, stdout);
 	  if (ferror (stdout))
 	    clearerr (stdout);
 	  if (termscript)
-	    fwrite (GLYPH_STRING (tbase, g), 1, GLYPH_LENGTH (tbase, g),
-		    termscript);
+	    fwrite (conversion_buffer, 1, produced, termscript);
 	}
 
       OUTPUT1_IF (TS_pad_inserted_char);
@@ -1558,6 +1650,10 @@ to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
   Wcm.cm_tab = tgetstr ("ta", address);
   TS_end_termcap_modes = tgetstr ("te", address);
   TS_termcap_modes = tgetstr ("ti", address);
+  TS_bold_mode = tgetstr ("md", address);
+  TS_end_bold_mode = tgetstr ("me", address);
+  TS_underscore_mode = tgetstr ("us", address);
+  TS_end_underscore_mode = tgetstr ("ue", address);
   Up = tgetstr ("up", address);
   TS_visible_bell = tgetstr ("vb", address);
   TS_end_visual_mode = tgetstr ("ve", address);