comparison src/term.c @ 765:e4093444f9f8

*** empty log message ***

764:bb24f1180bb6

#include "termchar.h"
#include "termopts.h"
#include "cm.h"
#undef NULL
#include "lisp.h"
#include "screen.h"
#include "disptab.h"
#include "termhooks.h"
#include "keyboard.h"

#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))

#define OUTPUT(a) tputs (a, SCREEN_HEIGHT (selected_screen) - curY, cmputc)
#define OUTPUT1(a) tputs (a, 1, cmputc)
#define OUTPUTL(a, lines) tputs (a, lines, cmputc)
#define OUTPUT_IF(a) { if (a) tputs (a, SCREEN_HEIGHT (selected_screen) - curY, cmputc); }
#define OUTPUT1_IF(a) { if (a) tputs (a, 1, cmputc); }

/* Terminal charateristics that higher levels want to look at.
   These are all extern'd in termchar.h */

int line_ins_del_ok;		/* Terminal can insert and delete lines */
int char_ins_del_ok;		/* Terminal can insert and delete chars */
int scroll_region_ok;		/* Terminal supports setting the
				   scroll window */
int memory_below_screen;	/* Terminal remembers lines
				   scrolled off bottom */
int fast_clear_end_of_line;	/* Terminal has a `ce' string */

int dont_calculate_costs;	/* Nonzero means don't bother computing */
				/* various cost tables; we won't use them.  */

/* Nonzero means no need to redraw the entire screen on resuming
   a suspended Emacs.  This is useful on terminals with multiple pages,
   where one page is used for Emacs and another for all else. */
int no_redraw_on_reenter;

/* Hook functions that you can set to snap out the functions in this file.

int (*cursor_to_hook) ();
int (*raw_cursor_to_hook) ();

int (*clear_to_end_hook) ();
int (*clear_screen_hook) ();
int (*clear_end_of_line_hook) ();

int (*ins_del_lines_hook) ();

int (*change_line_highlight_hook) ();

int (*read_socket_hook) ();

/* Return the current position of the mouse.  This should clear
   mouse_moved until the next motion event arrives.  */
void (*mouse_position_hook) ( /* SCREEN_PTR *s,
					Lisp_Object *x,
					Lisp_Object *y,
					unsigned long *time */ );

/* When reading from a minibuffer in a different screen, Emacs wants
   to shift the highlight from the selected screen to the minibuffer's
   screen; under X, this means it lies about where the focus is.
   This hook tells the window system code to re-decide where to put
   the highlight.  */
void (*screen_rehighlight_hook) ( /* SCREEN_PTR s */ );

/* Strings, numbers and flags taken from the termcap entry.  */

char *TS_ins_line;		/* termcap "al" */
char *TS_ins_multi_lines;	/* "AL" (one parameter, # lines to insert) */
char *TS_bell;			/* "bl" */
char *TS_clr_to_bottom;		/* "cd" */
char *TS_clr_line;		/* "ce", clear to end of line */
char *TS_clr_screen;		/* "cl" */
char *TS_set_scroll_region;	/* "cs" (2 params, first line and last line) */
char *TS_set_scroll_region_1;   /* "cS" (4 params: total lines,
				   lines above scroll region, lines below it,
				   total lines again) */
char *TS_del_char;		/* "dc" */

int insert_mode;			/* Nonzero when in insert mode.  */
int standout_mode;			/* Nonzero when in standout mode.  */

/* Size of window specified by higher levels.
   This is the number of lines, from the top of screen downwards,
   which can participate in insert-line/delete-line operations.

   Effectively it excludes the bottom screen_height - specified_window_size
   lines from those operations.  */

int specified_window;

/* Screen currently being redisplayed; 0 if not currently redisplaying.
   (Direct output does not count).  */

SCREEN_PTR updating_screen;

char *tparam ();

ring_bell ()
{
  if (! SCREEN_IS_TERMCAP (selected_screen))
    {
      (*ring_bell_hook) ();
      return;
    }
  OUTPUT (TS_visible_bell && visible_bell ? TS_visible_bell : TS_bell);
}

set_terminal_modes ()
{
  if (! SCREEN_IS_TERMCAP (selected_screen))
    {
      (*set_terminal_modes_hook) ();
      return;
    }
  OUTPUT_IF (TS_termcap_modes);

  losecursor ();
}

reset_terminal_modes ()
{
  if (! SCREEN_IS_TERMCAP (selected_screen))
    {
      (*reset_terminal_modes_hook) ();
      return;
    }
  if (TN_standout_width < 0)

  OUTPUT_IF (TS_end_keypad_mode);
  OUTPUT_IF (TS_end_visual_mode);
  OUTPUT_IF (TS_end_termcap_modes);
  /* Output raw CR so kernel can track the cursor hpos.  */
  /* But on magic-cookie terminals this can erase an end-standout marker and
     cause the rest of the screen to be in standout, so move down first.  */
  if (TN_standout_width >= 0)
    cmputc ('\n');
  cmputc ('\r');
}

update_begin (s)
     SCREEN_PTR s;
{
  updating_screen = s;
  if (! SCREEN_IS_TERMCAP (updating_screen))
    (*update_begin_hook) (s);
}

update_end (s)
     SCREEN_PTR s;
{
  if (! SCREEN_IS_TERMCAP (updating_screen))
    {
      (*update_end_hook) (s);
      updating_screen = 0;
      return;
    }
  turn_off_insert ();
  background_highlight ();
  standout_requested = 0;
  updating_screen = 0;
}

set_terminal_window (size)
     int size;
{
  if (! SCREEN_IS_TERMCAP (updating_screen))
    {
      (*set_terminal_window_hook) (size);
      return;
    }
  specified_window = size ? size : SCREEN_HEIGHT (selected_screen);
  if (!scroll_region_ok)
    return;
  set_scroll_region (0, specified_window);
}

      buf = tparam (TS_set_scroll_region, 0, 0, start, stop - 1);
    }
  else if (TS_set_scroll_region_1)
    {
      buf = tparam (TS_set_scroll_region_1, 0, 0,
		    SCREEN_HEIGHT (selected_screen), start,
		    SCREEN_HEIGHT (selected_screen) - stop,
		    SCREEN_HEIGHT (selected_screen));
    }
  else
    {
      buf = tparam (TS_set_window, 0, 0, start, 0, stop, SCREEN_WIDTH (selected_screen));
    }
  OUTPUT (buf);
  free (buf);
  losecursor ();
}

    turn_on_highlight ();
}

/* Handle standout mode for terminals in which TN_standout_width >= 0.
   On these terminals, standout is controlled by markers that
   live inside the screen memory.  TN_standout_width is the width
   that the marker occupies in memory.  Standout runs from the marker
   to the end of the line on some terminals, or to the next
   turn-off-standout marker (TS_end_standout_mode) string
   on other terminals.  */

reassert_line_highlight (highlight, vpos)
     int highlight;
     int vpos;
{
  if (! SCREEN_IS_TERMCAP ((updating_screen ? updating_screen : selected_screen)))
    {
      (*reassert_line_highlight_hook) (highlight, vpos);
      return;
    }
  if (TN_standout_width < 0)

change_line_highlight (new_highlight, vpos, first_unused_hpos)
     int new_highlight, vpos, first_unused_hpos;
{
  standout_requested = new_highlight;
  if (! SCREEN_IS_TERMCAP (updating_screen))
    {
      (*change_line_highlight_hook) (new_highlight, vpos, first_unused_hpos);
      return;
    }

    {
      turn_off_insert ();
      /* On Teleray, make sure to erase the SO marker.  */
      if (TF_teleray)
	{
	  cmgoto (curY - 1, SCREEN_WIDTH (selected_screen) - 4);
	  OUTPUT ("\033S");
	  curY++;		/* ESC S moves to next line where the TS_standout_mode was */
	  curX = 0;
	}
      else

/* Move to absolute position, specified origin 0 */

cursor_to (row, col)
     int row, col;
{
  if (! SCREEN_IS_TERMCAP ((updating_screen
			    ? updating_screen
			    : selected_screen))
      && cursor_to_hook)
    {
      (*cursor_to_hook) (row, col);
      return;
    }

/* Similar but don't take any account of the wasted characters.  */

raw_cursor_to (row, col)
     int row, col;
{
  if (! SCREEN_IS_TERMCAP ((updating_screen ? updating_screen : selected_screen)))
    {
      (*raw_cursor_to_hook) (row, col);
      return;
    }
  if (curY == row && curX == col)

  cmgoto (row, col);
}

/* Erase operations */

/* clear from cursor to end of screen */
clear_to_end ()
{
  register int i;

  if (clear_to_end_hook && SCREEN_IS_TERMCAP (updating_screen))
    {
      (*clear_to_end_hook) ();
      return;
    }
  if (TS_clr_to_bottom)
    {
      background_highlight ();
      OUTPUT (TS_clr_to_bottom);
      bzero (chars_wasted + curY, SCREEN_HEIGHT (selected_screen) - curY);
    }
  else
    {
      for (i = curY; i < SCREEN_HEIGHT (selected_screen); i++)
	{
	  cursor_to (i, 0);
	  clear_end_of_line_raw (SCREEN_WIDTH (selected_screen));
	}
    }
}

/* Clear entire screen */

clear_screen ()
{
  if (clear_screen_hook
      && ! SCREEN_IS_TERMCAP ((updating_screen ? updating_screen : selected_screen)))
    {
      (*clear_screen_hook) ();
      return;
    }
  if (TS_clr_screen)
    {
      background_highlight ();
      OUTPUT (TS_clr_screen);
      bzero (chars_wasted, SCREEN_HEIGHT (selected_screen));
      cmat (0, 0);
    }
  else
    {
      cursor_to (0, 0);

clear_end_of_line (first_unused_hpos)
     int first_unused_hpos;
{
  static GLYPH buf[1] = {SPACEGLYPH};
  if (SCREEN_IS_TERMCAP (selected_screen)
      && TN_standout_width == 0 && curX == 0 && chars_wasted[curY] != 0)
    write_glyphs (buf, 1);
  clear_end_of_line_raw (first_unused_hpos);
}

     int first_unused_hpos;
{
  register int i;

  if (clear_end_of_line_hook
      && ! SCREEN_IS_TERMCAP ((updating_screen
			       ? updating_screen
			       : selected_screen)))
    {
      (*clear_end_of_line_hook) (first_unused_hpos);
      return;
    }

  else
    {			/* have to do it the hard way */
      turn_off_insert ();

      /* Do not write in last row last col with Autowrap on. */
      if (AutoWrap && curY == SCREEN_HEIGHT (selected_screen) - 1
	  && first_unused_hpos == SCREEN_WIDTH (selected_screen))
	first_unused_hpos--;

      for (i = curX; i < first_unused_hpos; i++)
	{
	  if (termscript)

  register GLYPH g;
  register int tlen = GLYPH_TABLE_LENGTH;
  register Lisp_Object *tbase = GLYPH_TABLE_BASE;

  if (write_glyphs_hook
      && ! SCREEN_IS_TERMCAP ((updating_screen ? updating_screen : selected_screen)))
    {
      (*write_glyphs_hook) (string, len);
      return;
    }

  highlight_if_desired ();
  turn_off_insert ();

  /* Don't dare write in last column of bottom line, if AutoWrap,
     since that would scroll the whole screen on some terminals.  */

  if (AutoWrap
      && curY + 1 == SCREEN_HEIGHT (selected_screen)
      && (curX + len - (chars_wasted[curY] & 077)
	  == SCREEN_WIDTH (selected_screen)))
    len --;

  cmplus (len);
  while (--len >= 0)
    {

  char *buf;
  register GLYPH g;
  register int tlen = GLYPH_TABLE_LENGTH;
  register Lisp_Object *tbase = GLYPH_TABLE_BASE;

  if (insert_glyphs_hook && ! SCREEN_IS_TERMCAP (updating_screen))
    {
      (*insert_glyphs_hook) (start, len);
      return;
    }
  highlight_if_desired ();

     register int n;
{
  char *buf;
  register int i;

  if (delete_glyphs_hook && ! SCREEN_IS_TERMCAP (updating_screen))
    {
      (*delete_glyphs_hook) (n);
      return;
    }

  char *scroll = n > 0 ? TS_rev_scroll : TS_fwd_scroll;

  register int i = n > 0 ? n : -n;
  register char *buf;

  if (ins_del_lines_hook && ! SCREEN_IS_TERMCAP (updating_screen))
    {
      (*ins_del_lines_hook) (vpos, n);
      return;
    }

  /* If the lines below the deletion are blank lines coming
     out of the end of the window, don't bother,
     as there will be a matching inslines later that will flush them. */
  if (scroll_region_ok && vpos + i >= specified_window)
    return;
  if (!memory_below_screen && vpos + i >= SCREEN_HEIGHT (selected_screen))
    return;

  if (multi)
    {
      raw_cursor_to (vpos, 0);

  if (TN_standout_width >= 0)
    {
      register lower_limit
	= (scroll_region_ok
	   ? specified_window
	   : SCREEN_HEIGHT (selected_screen));

      if (n < 0)
	{
	  bcopy (&chars_wasted[vpos - n], &chars_wasted[vpos],
		 lower_limit - vpos + n);

	  bcopy (&copybuf[vpos], &chars_wasted[vpos + n],
		 lower_limit - vpos - n);
	  bzero (&chars_wasted[vpos], n);
	}
    }
  if (!scroll_region_ok && memory_below_screen && n < 0)
    {
      cursor_to (SCREEN_HEIGHT (selected_screen) + n, 0);
      clear_to_end ();
    }
}

/* Compute cost of sending "str", in characters,

/* char_ins_del_cost[n] is cost of inserting N characters.
   char_ins_del_cost[-n] is cost of deleting N characters. */

int *char_ins_del_vector;

#define char_ins_del_cost(s) (&char_ins_del_vector[SCREEN_WIDTH ((s))])
#endif

/* ARGSUSED */
static void
calculate_ins_del_char_costs (screen)
     SCREEN_PTR screen;
{
  int ins_startup_cost, del_startup_cost;
  int ins_cost_per_char, del_cost_per_char;
  register int i;
  register int *p;

      del_startup_cost = 9999;
      del_cost_per_char = 0;
    }

  /* Delete costs are at negative offsets */
  p = &char_ins_del_cost (screen)[0];
  for (i = SCREEN_WIDTH (selected_screen); --i >= 0;)
    *--p = (del_startup_cost += del_cost_per_char);

  /* Doing nothing is free */
  p = &char_ins_del_cost (screen)[0];
  *p++ = 0;

  /* Insert costs are at positive offsets */
  for (i = SCREEN_WIDTH (screen); --i >= 0;)
    *p++ = (ins_startup_cost += ins_cost_per_char);
}

#ifdef HAVE_X_WINDOWS
extern int x_screen_planes;
#endif

calculate_costs (screen)
     SCREEN_PTR screen;
{
  register char *s = TS_set_scroll_region ?
                       TS_set_scroll_region
		     : TS_set_scroll_region_1;

  if (dont_calculate_costs)
    return;

#ifdef HAVE_X_WINDOWS
  if (SCREEN_IS_X (screen))
    {
      do_line_insertion_deletion_costs (screen, 0, ".5*", 0, ".5*",
					0, 0, x_screen_planes);
      return;
    }
#endif

  /* These variables are only used for terminal stuff.  They are allocated
     once for the terminal screen of X-windows emacs, but not used afterwards.

     char_ins_del_vector (i.e., char_ins_del_cost) isn't used because
     X turns off char_ins_del_ok.

     chars_wasted and copybuf are only used here in term.c in cases where
     the term hook isn't called. */

  if (chars_wasted != 0)
    chars_wasted = (char *) xrealloc (chars_wasted, SCREEN_HEIGHT (screen));
  else
    chars_wasted = (char *) xmalloc (SCREEN_HEIGHT (screen));

  if (copybuf != 0)
    copybuf = (char *) xrealloc (copybuf, SCREEN_HEIGHT (screen));
  else
    copybuf = (char *) xmalloc (SCREEN_HEIGHT (screen));

  if (char_ins_del_vector != 0)
    char_ins_del_vector
      = (int *) xrealloc (char_ins_del_vector,
			  (sizeof (int)
			   + 2 * SCREEN_WIDTH (screen) * sizeof (int)));
  else
    char_ins_del_vector
      = (int *) xmalloc (sizeof (int)
			 + 2 * SCREEN_WIDTH (screen) * sizeof (int));

  bzero (chars_wasted, SCREEN_HEIGHT (screen));
  bzero (copybuf, SCREEN_HEIGHT (screen));
  bzero (char_ins_del_vector, (sizeof (int)
			       + 2 * SCREEN_WIDTH (screen) * sizeof (int)));

  if (s && (!TS_ins_line && !TS_del_line))
    do_line_insertion_deletion_costs (screen,
				      TS_rev_scroll, TS_ins_multi_lines,
				      TS_fwd_scroll, TS_del_multi_lines,
				      s, s, 1);
  else
    do_line_insertion_deletion_costs (screen,
				      TS_ins_line, TS_ins_multi_lines,
				      TS_del_line, TS_del_multi_lines,
				      0, 0, 1);

  calculate_ins_del_char_costs (screen);

  /* Don't use TS_repeat if its padding is worse than sending the chars */
  if (TS_repeat && per_line_cost (TS_repeat) * baud_rate < 9000)
    RPov = string_cost (TS_repeat);
  else
    RPov = SCREEN_WIDTH (screen) * 2;

  cmcostinit ();		/* set up cursor motion costs */
}

/* Find the escape codes sent by the function keys for Vfunction_key_map.

  TS_ins_multi_lines = tgetstr ("AL", address);
  TS_bell = tgetstr ("bl", address);
  BackTab = tgetstr ("bt", address);
  TS_clr_to_bottom = tgetstr ("cd", address);
  TS_clr_line = tgetstr ("ce", address);
  TS_clr_screen = tgetstr ("cl", address);
  ColPosition = tgetstr ("ch", address);
  AbsPosition = tgetstr ("cm", address);
  CR = tgetstr ("cr", address);
  TS_set_scroll_region = tgetstr ("cs", address);
  TS_set_scroll_region_1 = tgetstr ("cS", address);

  MultiDown = tgetstr ("DO", address);
  MultiLeft = tgetstr ("LE", address);
  MultiRight = tgetstr ("RI", address);

  AutoWrap = tgetflag ("am");
  memory_below_screen = tgetflag ("db");
  TF_hazeltine = tgetflag ("hz");
  must_write_spaces = tgetflag ("in");
  meta_key = tgetflag ("km") || tgetflag ("MT");
  TF_insmode_motion = tgetflag ("mi");
  TF_standout_motion = tgetflag ("ms");

  TF_xs = tgetflag ("xs");
  TF_teleray = tgetflag ("xt");

  term_get_fkeys (address);

  /* Get screen size from system, or else from termcap.  */
  get_screen_size (&SCREEN_WIDTH (selected_screen),
		   &SCREEN_HEIGHT (selected_screen));
  if (SCREEN_WIDTH (selected_screen) <= 0)
    SCREEN_WIDTH (selected_screen) = tgetnum ("co");
  if (SCREEN_HEIGHT (selected_screen) <= 0)
    SCREEN_HEIGHT (selected_screen) = tgetnum ("li");

  min_padding_speed = tgetnum ("pb");
  TN_standout_width = tgetnum ("sg");
  TabWidth = tgetnum ("tw");

  /* Special handling for certain terminal types known to need it */

  if (!strcmp (terminal_type, "supdup"))
    {
      memory_below_screen = 1;
      Wcm.cm_losewrap = 1;
    }
  if (!strncmp (terminal_type, "c10", 3)
      || !strcmp (terminal_type, "perq"))
    {
      /* Supply a makeshift :wi string.
	 This string is not valid in general since it works only
	 for windows starting at the upper left corner;
	 but that is all Emacs uses.

	 This string works only if the screen is using
	 the top of the video memory, because addressing is memory-relative.
	 So first check the :ti string to see if that is true.

	 It would be simpler if the :wi string could go in the termcap
	 entry, but it can't because it is not fully valid.

	    p[1] = 'C';
	  p++;
	}
    }

  ScreenRows = SCREEN_HEIGHT (selected_screen);
  ScreenCols = SCREEN_WIDTH (selected_screen);
  specified_window = SCREEN_HEIGHT (selected_screen);

  if (Wcm_init () == -1)	/* can't do cursor motion */
#ifdef VMS
    fatal ("Terminal type \"%s\" is not powerful enough to run Emacs.\n\
It lacks the ability to position the cursor.\n\

If that is not the actual type of terminal you have,\n\
use the C-shell command `setenv TERM ...' to specify the correct type.\n\
It may be necessary to do `unsetenv TERMCAP' as well.\n",
	   terminal_type);
#endif
  if (SCREEN_HEIGHT (selected_screen) <= 0
      || SCREEN_WIDTH (selected_screen) <= 0)
    fatal ("The screen size has not been specified.");

  delete_in_insert_mode
    = TS_delete_mode && TS_insert_mode
      && !strcmp (TS_delete_mode, TS_insert_mode);

	      && TS_end_standout_mode
	      && !strcmp (TS_standout_mode, TS_end_standout_mode));

  /* Remove width of standout marker from usable width of line */
  if (TN_standout_width > 0)
    SCREEN_WIDTH (selected_screen) -= TN_standout_width;

  UseTabs = tabs_safe_p () && TabWidth == 8;

  scroll_region_ok
    = (Wcm.cm_abs

765:e4093444f9f8

#include "termchar.h"
#include "termopts.h"
#include "cm.h"
#undef NULL
#include "lisp.h"
#include "frame.h"
#include "disptab.h"
#include "termhooks.h"
#include "keyboard.h"

#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))

#define OUTPUT(a) tputs (a, FRAME_HEIGHT (selected_frame) - curY, cmputc)
#define OUTPUT1(a) tputs (a, 1, cmputc)
#define OUTPUTL(a, lines) tputs (a, lines, cmputc)
#define OUTPUT_IF(a) { if (a) tputs (a, FRAME_HEIGHT (selected_frame) - curY, cmputc); }
#define OUTPUT1_IF(a) { if (a) tputs (a, 1, cmputc); }

/* Terminal charateristics that higher levels want to look at.
   These are all extern'd in termchar.h */

int line_ins_del_ok;		/* Terminal can insert and delete lines */
int char_ins_del_ok;		/* Terminal can insert and delete chars */
int scroll_region_ok;		/* Terminal supports setting the
				   scroll window */
int memory_below_frame;		/* Terminal remembers lines
				   scrolled off bottom */
int fast_clear_end_of_line;	/* Terminal has a `ce' string */

int dont_calculate_costs;	/* Nonzero means don't bother computing */
				/* various cost tables; we won't use them.  */

/* Nonzero means no need to redraw the entire frame on resuming
   a suspended Emacs.  This is useful on terminals with multiple pages,
   where one page is used for Emacs and another for all else. */
int no_redraw_on_reenter;

/* Hook functions that you can set to snap out the functions in this file.

int (*cursor_to_hook) ();
int (*raw_cursor_to_hook) ();

int (*clear_to_end_hook) ();
int (*clear_frame_hook) ();
int (*clear_end_of_line_hook) ();

int (*ins_del_lines_hook) ();

int (*change_line_highlight_hook) ();

int (*read_socket_hook) ();

/* Return the current position of the mouse.  This should clear
   mouse_moved until the next motion event arrives.  */
void (*mouse_position_hook) ( /* FRAME_PTR *f,
					Lisp_Object *x,
					Lisp_Object *y,
					unsigned long *time */ );

/* When reading from a minibuffer in a different frame, Emacs wants
   to shift the highlight from the selected frame to the minibuffer's
   frame; under X, this means it lies about where the focus is.
   This hook tells the window system code to re-decide where to put
   the highlight.  */
void (*frame_rehighlight_hook) ( /* FRAME_PTR f */ );

/* Strings, numbers and flags taken from the termcap entry.  */

char *TS_ins_line;		/* termcap "al" */
char *TS_ins_multi_lines;	/* "AL" (one parameter, # lines to insert) */
char *TS_bell;			/* "bl" */
char *TS_clr_to_bottom;		/* "cd" */
char *TS_clr_line;		/* "ce", clear to end of line */
char *TS_clr_frame;		/* "cl" */
char *TS_set_scroll_region;	/* "cs" (2 params, first line and last line) */
char *TS_set_scroll_region_1;   /* "cS" (4 params: total lines,
				   lines above scroll region, lines below it,
				   total lines again) */
char *TS_del_char;		/* "dc" */

int insert_mode;			/* Nonzero when in insert mode.  */
int standout_mode;			/* Nonzero when in standout mode.  */

/* Size of window specified by higher levels.
   This is the number of lines, from the top of frame downwards,
   which can participate in insert-line/delete-line operations.

   Effectively it excludes the bottom frame_height - specified_window_size
   lines from those operations.  */

int specified_window;

/* Frame currently being redisplayed; 0 if not currently redisplaying.
   (Direct output does not count).  */

FRAME_PTR updating_frame;

char *tparam ();

ring_bell ()
{
  if (! FRAME_IS_TERMCAP (selected_frame))
    {
      (*ring_bell_hook) ();
      return;
    }
  OUTPUT (TS_visible_bell && visible_bell ? TS_visible_bell : TS_bell);
}

set_terminal_modes ()
{
  if (! FRAME_IS_TERMCAP (selected_frame))
    {
      (*set_terminal_modes_hook) ();
      return;
    }
  OUTPUT_IF (TS_termcap_modes);

  losecursor ();
}

reset_terminal_modes ()
{
  if (! FRAME_IS_TERMCAP (selected_frame))
    {
      (*reset_terminal_modes_hook) ();
      return;
    }
  if (TN_standout_width < 0)

  OUTPUT_IF (TS_end_keypad_mode);
  OUTPUT_IF (TS_end_visual_mode);
  OUTPUT_IF (TS_end_termcap_modes);
  /* Output raw CR so kernel can track the cursor hpos.  */
  /* But on magic-cookie terminals this can erase an end-standout marker and
     cause the rest of the frame to be in standout, so move down first.  */
  if (TN_standout_width >= 0)
    cmputc ('\n');
  cmputc ('\r');
}

update_begin (f)
     FRAME_PTR f;
{
  updating_frame = f;
  if (! FRAME_IS_TERMCAP (updating_frame))
    (*update_begin_hook) (f);
}

update_end (f)
     FRAME_PTR f;
{
  if (! FRAME_IS_TERMCAP (updating_frame))
    {
      (*update_end_hook) (f);
      updating_frame = 0;
      return;
    }
  turn_off_insert ();
  background_highlight ();
  standout_requested = 0;
  updating_frame = 0;
}

set_terminal_window (size)
     int size;
{
  if (! FRAME_IS_TERMCAP (updating_frame))
    {
      (*set_terminal_window_hook) (size);
      return;
    }
  specified_window = size ? size : FRAME_HEIGHT (selected_frame);
  if (!scroll_region_ok)
    return;
  set_scroll_region (0, specified_window);
}

      buf = tparam (TS_set_scroll_region, 0, 0, start, stop - 1);
    }
  else if (TS_set_scroll_region_1)
    {
      buf = tparam (TS_set_scroll_region_1, 0, 0,
		    FRAME_HEIGHT (selected_frame), start,
		    FRAME_HEIGHT (selected_frame) - stop,
		    FRAME_HEIGHT (selected_frame));
    }
  else
    {
      buf = tparam (TS_set_window, 0, 0, start, 0, stop, FRAME_WIDTH (selected_frame));
    }
  OUTPUT (buf);
  free (buf);
  losecursor ();
}

    turn_on_highlight ();
}

/* Handle standout mode for terminals in which TN_standout_width >= 0.
   On these terminals, standout is controlled by markers that
   live inside the terminal's memory.  TN_standout_width is the width
   that the marker occupies in memory.  Standout runs from the marker
   to the end of the line on some terminals, or to the next
   turn-off-standout marker (TS_end_standout_mode) string
   on other terminals.  */

reassert_line_highlight (highlight, vpos)
     int highlight;
     int vpos;
{
  if (! FRAME_IS_TERMCAP ((updating_frame ? updating_frame : selected_frame)))
    {
      (*reassert_line_highlight_hook) (highlight, vpos);
      return;
    }
  if (TN_standout_width < 0)

change_line_highlight (new_highlight, vpos, first_unused_hpos)
     int new_highlight, vpos, first_unused_hpos;
{
  standout_requested = new_highlight;
  if (! FRAME_IS_TERMCAP (updating_frame))
    {
      (*change_line_highlight_hook) (new_highlight, vpos, first_unused_hpos);
      return;
    }

    {
      turn_off_insert ();
      /* On Teleray, make sure to erase the SO marker.  */
      if (TF_teleray)
	{
	  cmgoto (curY - 1, FRAME_WIDTH (selected_frame) - 4);
	  OUTPUT ("\033S");
	  curY++;		/* ESC S moves to next line where the TS_standout_mode was */
	  curX = 0;
	}
      else

/* Move to absolute position, specified origin 0 */

cursor_to (row, col)
     int row, col;
{
  if (! FRAME_IS_TERMCAP ((updating_frame
			    ? updating_frame
			    : selected_frame))
      && cursor_to_hook)
    {
      (*cursor_to_hook) (row, col);
      return;
    }

/* Similar but don't take any account of the wasted characters.  */

raw_cursor_to (row, col)
     int row, col;
{
  if (! FRAME_IS_TERMCAP ((updating_frame ? updating_frame : selected_frame)))
    {
      (*raw_cursor_to_hook) (row, col);
      return;
    }
  if (curY == row && curX == col)

  cmgoto (row, col);
}

/* Erase operations */

/* clear from cursor to end of frame */
clear_to_end ()
{
  register int i;

  if (clear_to_end_hook && FRAME_IS_TERMCAP (updating_frame))
    {
      (*clear_to_end_hook) ();
      return;
    }
  if (TS_clr_to_bottom)
    {
      background_highlight ();
      OUTPUT (TS_clr_to_bottom);
      bzero (chars_wasted + curY, FRAME_HEIGHT (selected_frame) - curY);
    }
  else
    {
      for (i = curY; i < FRAME_HEIGHT (selected_frame); i++)
	{
	  cursor_to (i, 0);
	  clear_end_of_line_raw (FRAME_WIDTH (selected_frame));
	}
    }
}

/* Clear entire frame */

clear_frame ()
{
  if (clear_frame_hook
      && ! FRAME_IS_TERMCAP ((updating_frame ? updating_frame : selected_frame)))
    {
      (*clear_frame_hook) ();
      return;
    }
  if (TS_clr_frame)
    {
      background_highlight ();
      OUTPUT (TS_clr_frame);
      bzero (chars_wasted, FRAME_HEIGHT (selected_frame));
      cmat (0, 0);
    }
  else
    {
      cursor_to (0, 0);

clear_end_of_line (first_unused_hpos)
     int first_unused_hpos;
{
  static GLYPH buf[1] = {SPACEGLYPH};
  if (FRAME_IS_TERMCAP (selected_frame)
      && TN_standout_width == 0 && curX == 0 && chars_wasted[curY] != 0)
    write_glyphs (buf, 1);
  clear_end_of_line_raw (first_unused_hpos);
}

     int first_unused_hpos;
{
  register int i;

  if (clear_end_of_line_hook
      && ! FRAME_IS_TERMCAP ((updating_frame
			       ? updating_frame
			       : selected_frame)))
    {
      (*clear_end_of_line_hook) (first_unused_hpos);
      return;
    }

  else
    {			/* have to do it the hard way */
      turn_off_insert ();

      /* Do not write in last row last col with Autowrap on. */
      if (AutoWrap && curY == FRAME_HEIGHT (selected_frame) - 1
	  && first_unused_hpos == FRAME_WIDTH (selected_frame))
	first_unused_hpos--;

      for (i = curX; i < first_unused_hpos; i++)
	{
	  if (termscript)

  register GLYPH g;
  register int tlen = GLYPH_TABLE_LENGTH;
  register Lisp_Object *tbase = GLYPH_TABLE_BASE;

  if (write_glyphs_hook
      && ! FRAME_IS_TERMCAP ((updating_frame ? updating_frame : selected_frame)))
    {
      (*write_glyphs_hook) (string, len);
      return;
    }

  highlight_if_desired ();
  turn_off_insert ();

  /* Don't dare write in last column of bottom line, if AutoWrap,
     since that would scroll the whole frame on some terminals.  */

  if (AutoWrap
      && curY + 1 == FRAME_HEIGHT (selected_frame)
      && (curX + len - (chars_wasted[curY] & 077)
	  == FRAME_WIDTH (selected_frame)))
    len --;

  cmplus (len);
  while (--len >= 0)
    {

  char *buf;
  register GLYPH g;
  register int tlen = GLYPH_TABLE_LENGTH;
  register Lisp_Object *tbase = GLYPH_TABLE_BASE;

  if (insert_glyphs_hook && ! FRAME_IS_TERMCAP (updating_frame))
    {
      (*insert_glyphs_hook) (start, len);
      return;
    }
  highlight_if_desired ();

     register int n;
{
  char *buf;
  register int i;

  if (delete_glyphs_hook && ! FRAME_IS_TERMCAP (updating_frame))
    {
      (*delete_glyphs_hook) (n);
      return;
    }

  char *scroll = n > 0 ? TS_rev_scroll : TS_fwd_scroll;

  register int i = n > 0 ? n : -n;
  register char *buf;

  if (ins_del_lines_hook && ! FRAME_IS_TERMCAP (updating_frame))
    {
      (*ins_del_lines_hook) (vpos, n);
      return;
    }

  /* If the lines below the deletion are blank lines coming
     out of the end of the window, don't bother,
     as there will be a matching inslines later that will flush them. */
  if (scroll_region_ok && vpos + i >= specified_window)
    return;
  if (!memory_below_frame && vpos + i >= FRAME_HEIGHT (selected_frame))
    return;

  if (multi)
    {
      raw_cursor_to (vpos, 0);

  if (TN_standout_width >= 0)
    {
      register lower_limit
	= (scroll_region_ok
	   ? specified_window
	   : FRAME_HEIGHT (selected_frame));

      if (n < 0)
	{
	  bcopy (&chars_wasted[vpos - n], &chars_wasted[vpos],
		 lower_limit - vpos + n);

	  bcopy (&copybuf[vpos], &chars_wasted[vpos + n],
		 lower_limit - vpos - n);
	  bzero (&chars_wasted[vpos], n);
	}
    }
  if (!scroll_region_ok && memory_below_frame && n < 0)
    {
      cursor_to (FRAME_HEIGHT (selected_frame) + n, 0);
      clear_to_end ();
    }
}

/* Compute cost of sending "str", in characters,

/* char_ins_del_cost[n] is cost of inserting N characters.
   char_ins_del_cost[-n] is cost of deleting N characters. */

int *char_ins_del_vector;

#define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WIDTH ((f))])
#endif

/* ARGSUSED */
static void
calculate_ins_del_char_costs (frame)
     FRAME_PTR frame;
{
  int ins_startup_cost, del_startup_cost;
  int ins_cost_per_char, del_cost_per_char;
  register int i;
  register int *p;

      del_startup_cost = 9999;
      del_cost_per_char = 0;
    }

  /* Delete costs are at negative offsets */
  p = &char_ins_del_cost (frame)[0];
  for (i = FRAME_WIDTH (selected_frame); --i >= 0;)
    *--p = (del_startup_cost += del_cost_per_char);

  /* Doing nothing is free */
  p = &char_ins_del_cost (frame)[0];
  *p++ = 0;

  /* Insert costs are at positive offsets */
  for (i = FRAME_WIDTH (frame); --i >= 0;)
    *p++ = (ins_startup_cost += ins_cost_per_char);
}

#ifdef HAVE_X_WINDOWS
extern int x_frame_planes;
#endif

calculate_costs (frame)
     FRAME_PTR frame;
{
  register char *f = TS_set_scroll_region ?
                       TS_set_scroll_region
		     : TS_set_scroll_region_1;

  if (dont_calculate_costs)
    return;

#ifdef HAVE_X_WINDOWS
  if (FRAME_IS_X (frame))
    {
      do_line_insertion_deletion_costs (frame, 0, ".5*", 0, ".5*",
					0, 0, x_frame_planes);
      return;
    }
#endif

  /* These variables are only used for terminal stuff.  They are allocated
     once for the terminal frame of X-windows emacs, but not used afterwards.

     char_ins_del_vector (i.e., char_ins_del_cost) isn't used because
     X turns off char_ins_del_ok.

     chars_wasted and copybuf are only used here in term.c in cases where
     the term hook isn't called. */

  if (chars_wasted != 0)
    chars_wasted = (char *) xrealloc (chars_wasted, FRAME_HEIGHT (frame));
  else
    chars_wasted = (char *) xmalloc (FRAME_HEIGHT (frame));

  if (copybuf != 0)
    copybuf = (char *) xrealloc (copybuf, FRAME_HEIGHT (frame));
  else
    copybuf = (char *) xmalloc (FRAME_HEIGHT (frame));

  if (char_ins_del_vector != 0)
    char_ins_del_vector
      = (int *) xrealloc (char_ins_del_vector,
			  (sizeof (int)
			   + 2 * FRAME_WIDTH (frame) * sizeof (int)));
  else
    char_ins_del_vector
      = (int *) xmalloc (sizeof (int)
			 + 2 * FRAME_WIDTH (frame) * sizeof (int));

  bzero (chars_wasted, FRAME_HEIGHT (frame));
  bzero (copybuf, FRAME_HEIGHT (frame));
  bzero (char_ins_del_vector, (sizeof (int)
			       + 2 * FRAME_WIDTH (frame) * sizeof (int)));

  if (f && (!TS_ins_line && !TS_del_line))
    do_line_insertion_deletion_costs (frame,
				      TS_rev_scroll, TS_ins_multi_lines,
				      TS_fwd_scroll, TS_del_multi_lines,
				      f, f, 1);
  else
    do_line_insertion_deletion_costs (frame,
				      TS_ins_line, TS_ins_multi_lines,
				      TS_del_line, TS_del_multi_lines,
				      0, 0, 1);

  calculate_ins_del_char_costs (frame);

  /* Don't use TS_repeat if its padding is worse than sending the chars */
  if (TS_repeat && per_line_cost (TS_repeat) * baud_rate < 9000)
    RPov = string_cost (TS_repeat);
  else
    RPov = FRAME_WIDTH (frame) * 2;

  cmcostinit ();		/* set up cursor motion costs */
}

/* Find the escape codes sent by the function keys for Vfunction_key_map.

  TS_ins_multi_lines = tgetstr ("AL", address);
  TS_bell = tgetstr ("bl", address);
  BackTab = tgetstr ("bt", address);
  TS_clr_to_bottom = tgetstr ("cd", address);
  TS_clr_line = tgetstr ("ce", address);
  TS_clr_frame = tgetstr ("cl", address);
  ColPosition = tgetstr ("ch", address);
  AbsPosition = tgetstr ("cm", address);
  CR = tgetstr ("cr", address);
  TS_set_scroll_region = tgetstr ("cs", address);
  TS_set_scroll_region_1 = tgetstr ("cS", address);

  MultiDown = tgetstr ("DO", address);
  MultiLeft = tgetstr ("LE", address);
  MultiRight = tgetstr ("RI", address);

  AutoWrap = tgetflag ("am");
  memory_below_frame = tgetflag ("db");
  TF_hazeltine = tgetflag ("hz");
  must_write_spaces = tgetflag ("in");
  meta_key = tgetflag ("km") || tgetflag ("MT");
  TF_insmode_motion = tgetflag ("mi");
  TF_standout_motion = tgetflag ("ms");

  TF_xs = tgetflag ("xs");
  TF_teleray = tgetflag ("xt");

  term_get_fkeys (address);

  /* Get frame size from system, or else from termcap.  */
  get_frame_size (&FRAME_WIDTH (selected_frame),
		   &FRAME_HEIGHT (selected_frame));
  if (FRAME_WIDTH (selected_frame) <= 0)
    FRAME_WIDTH (selected_frame) = tgetnum ("co");
  if (FRAME_HEIGHT (selected_frame) <= 0)
    FRAME_HEIGHT (selected_frame) = tgetnum ("li");

  min_padding_speed = tgetnum ("pb");
  TN_standout_width = tgetnum ("sg");
  TabWidth = tgetnum ("tw");

  /* Special handling for certain terminal types known to need it */

  if (!strcmp (terminal_type, "supdup"))
    {
      memory_below_frame = 1;
      Wcm.cm_losewrap = 1;
    }
  if (!strncmp (terminal_type, "c10", 3)
      || !strcmp (terminal_type, "perq"))
    {
      /* Supply a makeshift :wi string.
	 This string is not valid in general since it works only
	 for windows starting at the upper left corner;
	 but that is all Emacs uses.

	 This string works only if the frame is using
	 the top of the video memory, because addressing is memory-relative.
	 So first check the :ti string to see if that is true.

	 It would be simpler if the :wi string could go in the termcap
	 entry, but it can't because it is not fully valid.

	    p[1] = 'C';
	  p++;
	}
    }

  FrameRows = FRAME_HEIGHT (selected_frame);
  FrameCols = FRAME_WIDTH (selected_frame);
  specified_window = FRAME_HEIGHT (selected_frame);

  if (Wcm_init () == -1)	/* can't do cursor motion */
#ifdef VMS
    fatal ("Terminal type \"%s\" is not powerful enough to run Emacs.\n\
It lacks the ability to position the cursor.\n\

If that is not the actual type of terminal you have,\n\
use the C-shell command `setenv TERM ...' to specify the correct type.\n\
It may be necessary to do `unsetenv TERMCAP' as well.\n",
	   terminal_type);
#endif
  if (FRAME_HEIGHT (selected_frame) <= 0
      || FRAME_WIDTH (selected_frame) <= 0)
    fatal ("The frame size has not been specified.");

  delete_in_insert_mode
    = TS_delete_mode && TS_insert_mode
      && !strcmp (TS_delete_mode, TS_insert_mode);

	      && TS_end_standout_mode
	      && !strcmp (TS_standout_mode, TS_end_standout_mode));

  /* Remove width of standout marker from usable width of line */
  if (TN_standout_width > 0)
    FRAME_WIDTH (selected_frame) -= TN_standout_width;

  UseTabs = tabs_safe_p () && TabWidth == 8;

  scroll_region_ok
    = (Wcm.cm_abs