text: /* vi:set ts=8 sts=4 sw=4 noet:
   *
   * VIM - Vi IMproved	by Bram Moolenaar
   *
   * Do ":help uganda"  in Vim to read copying and usage conditions.
   * Do ":help credits" in Vim to see a list of people who contributed.
   * See README.txt for an overview of the Vim source code.
   */
  
  /*
   * screen.c: code for displaying on the screen
   *
   * Output to the screen (console, terminal emulator or GUI window) is minimized
   * by remembering what is already on the screen, and only updating the parts
   * that changed.
   *
   * ScreenLines[off]  Contains a copy of the whole screen, as it is currently
   *		     displayed (excluding text written by external commands).
   * ScreenAttrs[off]  Contains the associated attributes.
   * LineOffset[row]   Contains the offset into ScreenLines*[] and ScreenAttrs[]
   *		     for each line.
   * LineWraps[row]    Flag for each line whether it wraps to the next line.
   *
   * For double-byte characters, two consecutive bytes in ScreenLines[] can form
   * one character which occupies two display cells.
   * For UTF-8 a multi-byte character is converted to Unicode and stored in
   * ScreenLinesUC[].  ScreenLines[] contains the first byte only.  For an ASCII
   * character without composing chars ScreenLinesUC[] will be 0 and
   * ScreenLinesC[][] is not used.  When the character occupies two display
   * cells the next byte in ScreenLines[] is 0.
   * ScreenLinesC[][] contain up to 'maxcombine' composing characters
   * (drawn on top of the first character).  There is 0 after the last one used.
   * ScreenLines2[] is only used for euc-jp to store the second byte if the
   * first byte is 0x8e (single-width character).
   *
   * The screen_*() functions write to the screen and handle updating
   * ScreenLines[].
   *
   * update_screen() is the function that updates all windows and status lines.
   * It is called form the main loop when must_redraw is non-zero.  It may be
   * called from other places when an immediate screen update is needed.
   *
   * The part of the buffer that is displayed in a window is set with:
   * - w_topline (first buffer line in window)
   * - w_topfill (filler lines above the first line)
   * - w_leftcol (leftmost window cell in window),
   * - w_skipcol (skipped window cells of first line)
   *
   * Commands that only move the cursor around in a window, do not need to take
   * action to update the display.  The main loop will check if w_topline is
   * valid and update it (scroll the window) when needed.
   *
   * Commands that scroll a window change w_topline and must call
   * check_cursor() to move the cursor into the visible part of the window, and
   * call redraw_later(VALID) to have the window displayed by update_screen()
   * later.
   *
   * Commands that change text in the buffer must call changed_bytes() or
   * changed_lines() to mark the area that changed and will require updating
   * later.  The main loop will call update_screen(), which will update each
   * window that shows the changed buffer.  This assumes text above the change
   * can remain displayed as it is.  Text after the change may need updating for
   * scrolling, folding and syntax highlighting.
   *
   * Commands that change how a window is displayed (e.g., setting 'list') or
   * invalidate the contents of a window in another way (e.g., change fold
   * settings), must call redraw_later(NOT_VALID) to have the whole window
   * redisplayed by update_screen() later.
   *
   * Commands that change how a buffer is displayed (e.g., setting 'tabstop')
   * must call redraw_curbuf_later(NOT_VALID) to have all the windows for the
   * buffer redisplayed by update_screen() later.
   *
   * Commands that change highlighting and possibly cause a scroll too must call
   * redraw_later(SOME_VALID) to update the whole window but still use scrolling
   * to avoid redrawing everything.  But the length of displayed lines must not
   * change, use NOT_VALID then.
   *
   * Commands that move the window position must call redraw_later(NOT_VALID).
   * TODO: should minimize redrawing by scrolling when possible.
   *
   * Commands that change everything (e.g., resizing the screen) must call
   * redraw_all_later(NOT_VALID) or redraw_all_later(CLEAR).
   *
   * Things that are handled indirectly:
   * - When messages scroll the screen up, msg_scrolled will be set and
   *   update_screen() called to redraw.
   */
  
  #include "vim.h"
  
  #define MB_FILLER_CHAR '<'  /* character used when a double-width character
  			     * doesn't fit. */
  
  /*
   * The attributes that are actually active for writing to the screen.
   */
  static int	screen_attr = 0;
  
  /*
   * Positioning the cursor is reduced by remembering the last position.
   * Mostly used by windgoto() and screen_char().
   */
  static int	screen_cur_row, screen_cur_col;	/* last known cursor position */
  
  #ifdef FEAT_SEARCH_EXTRA
  static match_T search_hl;	/* used for 'hlsearch' highlight matching */
  #endif
  
  #if defined(FEAT_MENU) || defined(FEAT_FOLDING)
  static int text_to_screenline(win_T *wp, char_u *text, int col);
  #endif
  #ifdef FEAT_FOLDING
  static foldinfo_T win_foldinfo;	/* info for 'foldcolumn' */
  static int compute_foldcolumn(win_T *wp, int col);
  #endif
  
  /* Flag that is set when drawing for a callback, not from the main command
   * loop. */
  static int redrawing_for_callback = 0;
  
  /*
   * Buffer for one screen line (characters and attributes).
   */
  static schar_T	*current_ScreenLine;
  
  static void win_update(win_T *wp);
  static void win_draw_end(win_T *wp, int c1, int c2, int row, int endrow, hlf_T hl);
  #ifdef FEAT_FOLDING
  static void fold_line(win_T *wp, long fold_count, foldinfo_T *foldinfo, linenr_T lnum, int row);
  static void fill_foldcolumn(char_u *p, win_T *wp, int closed, linenr_T lnum);
  static void copy_text_attr(int off, char_u *buf, int len, int attr);
  #endif
  static int win_line(win_T *, linenr_T, int, int, int nochange);
  static int char_needs_redraw(int off_from, int off_to, int cols);
  static void draw_vsep_win(win_T *wp, int row);
  #ifdef FEAT_STL_OPT
  static void redraw_custom_statusline(win_T *wp);
  #endif
  #ifdef FEAT_SEARCH_EXTRA
  # define SEARCH_HL_PRIORITY 0
  static void start_search_hl(void);
  static void end_search_hl(void);
  static void init_search_hl(win_T *wp);
  static void prepare_search_hl(win_T *wp, linenr_T lnum);
  static void next_search_hl(win_T *win, match_T *shl, linenr_T lnum, colnr_T mincol, matchitem_T *cur);
  static int next_search_hl_pos(match_T *shl, linenr_T lnum, posmatch_T *pos, colnr_T mincol);
  #endif
  static void screen_start_highlight(int attr);
  static void screen_char(unsigned off, int row, int col);
  #ifdef FEAT_MBYTE
  static void screen_char_2(unsigned off, int row, int col);
  #endif
  static void screenclear2(void);
  static void lineclear(unsigned off, int width, int attr);
  static void lineinvalid(unsigned off, int width);
  static void linecopy(int to, int from, win_T *wp);
  static void redraw_block(int row, int end, win_T *wp);
  static int win_do_lines(win_T *wp, int row, int line_count, int mayclear, int del, int clear_attr);
  static void win_rest_invalid(win_T *wp);
  static void msg_pos_mode(void);
  static void recording_mode(int attr);
  static void draw_tabline(void);
  static int fillchar_status(int *attr, win_T *wp);
  static int fillchar_vsep(int *attr);
  #ifdef FEAT_MENU
  static void redraw_win_toolbar(win_T *wp);
  #endif
  #ifdef FEAT_STL_OPT
  static void win_redr_custom(win_T *wp, int draw_ruler);
  #endif
  #ifdef FEAT_CMDL_INFO
  static void win_redr_ruler(win_T *wp, int always);
  #endif
  
  /* Ugly global: overrule attribute used by screen_char() */
  static int screen_char_attr = 0;
  
  #if defined(FEAT_SYN_HL) && defined(FEAT_RELTIME)
  /* Can limit syntax highlight time to 'redrawtime'. */
  # define SYN_TIME_LIMIT 1
  #endif
  
  #ifdef FEAT_RIGHTLEFT
  # define HAS_RIGHTLEFT(x) x
  #else
  # define HAS_RIGHTLEFT(x) FALSE
  #endif
  
  /*
   * Redraw the current window later, with update_screen(type).
   * Set must_redraw only if not already set to a higher value.
   * e.g. if must_redraw is CLEAR, type NOT_VALID will do nothing.
   */
      void
  redraw_later(int type)
  {
      redraw_win_later(curwin, type);
  }
  
      void
  redraw_win_later(
      win_T	*wp,
      int		type)
  {
      if (!exiting && wp->w_redr_type < type)
      {
  	wp->w_redr_type = type;
  	if (type >= NOT_VALID)
  	    wp->w_lines_valid = 0;
  	if (must_redraw < type)	/* must_redraw is the maximum of all windows */
  	    must_redraw = type;
      }
  }
  
  /*
   * Force a complete redraw later.  Also resets the highlighting.  To be used
   * after executing a shell command that messes up the screen.
   */
      void
  redraw_later_clear(void)
  {
      redraw_all_later(CLEAR);
  #ifdef FEAT_GUI
      if (gui.in_use)
  	/* Use a code that will reset gui.highlight_mask in
  	 * gui_stop_highlight(). */
  	screen_attr = HL_ALL + 1;
      else
  #endif
  	/* Use attributes that is very unlikely to appear in text. */
  	screen_attr = HL_BOLD | HL_UNDERLINE | HL_INVERSE | HL_STRIKETHROUGH;
  }
  
  /*
   * Mark all windows to be redrawn later.
   */
      void
  redraw_all_later(int type)
  {
      win_T	*wp;
  
      FOR_ALL_WINDOWS(wp)
      {
  	redraw_win_later(wp, type);
      }
  }
  
  /*
   * Mark all windows that are editing the current buffer to be updated later.
   */
      void
  redraw_curbuf_later(int type)
  {
      redraw_buf_later(curbuf, type);
  }
  
      void
  redraw_buf_later(buf_T *buf, int type)
  {
      win_T	*wp;
  
      FOR_ALL_WINDOWS(wp)
      {
  	if (wp->w_buffer == buf)
  	    redraw_win_later(wp, type);
      }
  }
  
      void
  redraw_buf_and_status_later(buf_T *buf, int type)
  {
      win_T	*wp;
  
  #ifdef FEAT_WILDMENU
      if (wild_menu_showing != 0)
  	/* Don't redraw while the command line completion is displayed, it
  	 * would disappear. */
  	return;
  #endif
      FOR_ALL_WINDOWS(wp)
      {
  	if (wp->w_buffer == buf)
  	{
  	    redraw_win_later(wp, type);
  	    wp->w_redr_status = TRUE;
  	}
      }
  }
  
  /*
   * Redraw as soon as possible.  When the command line is not scrolled redraw
   * right away and restore what was on the command line.
   * Return a code indicating what happened.
   */
      int
  redraw_asap(int type)
  {
      int		rows;
      int		cols = screen_Columns;
      int		r;
      int		ret = 0;
      schar_T	*screenline;	/* copy from ScreenLines[] */
      sattr_T	*screenattr;	/* copy from ScreenAttrs[] */
  #ifdef FEAT_MBYTE
      int		i;
      u8char_T	*screenlineUC = NULL;	/* copy from ScreenLinesUC[] */
      u8char_T	*screenlineC[MAX_MCO];	/* copy from ScreenLinesC[][] */
      schar_T	*screenline2 = NULL;	/* copy from ScreenLines2[] */
  #endif
  
      redraw_later(type);
      if (msg_scrolled || (State != NORMAL && State != NORMAL_BUSY) || exiting)
  	return ret;
  
      /* Allocate space to save the text displayed in the command line area. */
      rows = screen_Rows - cmdline_row;
      screenline = (schar_T *)lalloc(
  			   (long_u)(rows * cols * sizeof(schar_T)), FALSE);
      screenattr = (sattr_T *)lalloc(
  			   (long_u)(rows * cols * sizeof(sattr_T)), FALSE);
      if (screenline == NULL || screenattr == NULL)
  	ret = 2;
  #ifdef FEAT_MBYTE
      if (enc_utf8)
      {
  	screenlineUC = (u8char_T *)lalloc(
  			  (long_u)(rows * cols * sizeof(u8char_T)), FALSE);
  	if (screenlineUC == NULL)
  	    ret = 2;
  	for (i = 0; i < p_mco; ++i)
  	{
  	    screenlineC[i] = (u8char_T *)lalloc(
  			  (long_u)(rows * cols * sizeof(u8char_T)), FALSE);
  	    if (screenlineC[i] == NULL)
  		ret = 2;
  	}
      }
      if (enc_dbcs == DBCS_JPNU)
      {
  	screenline2 = (schar_T *)lalloc(
  			   (long_u)(rows * cols * sizeof(schar_T)), FALSE);
  	if (screenline2 == NULL)
  	    ret = 2;
      }
  #endif
  
      if (ret != 2)
      {
  	/* Save the text displayed in the command line area. */
  	for (r = 0; r < rows; ++r)
  	{
  	    mch_memmove(screenline + r * cols,
  			ScreenLines + LineOffset[cmdline_row + r],
  			(size_t)cols * sizeof(schar_T));
  	    mch_memmove(screenattr + r * cols,
  			ScreenAttrs + LineOffset[cmdline_row + r],
  			(size_t)cols * sizeof(sattr_T));
  #ifdef FEAT_MBYTE
  	    if (enc_utf8)
  	    {
  		mch_memmove(screenlineUC + r * cols,
  			    ScreenLinesUC + LineOffset[cmdline_row + r],
  			    (size_t)cols * sizeof(u8char_T));
  		for (i = 0; i < p_mco; ++i)
  		    mch_memmove(screenlineC[i] + r * cols,
  				ScreenLinesC[i] + LineOffset[cmdline_row + r],
  				(size_t)cols * sizeof(u8char_T));
  	    }
  	    if (enc_dbcs == DBCS_JPNU)
  		mch_memmove(screenline2 + r * cols,
  			    ScreenLines2 + LineOffset[cmdline_row + r],
  			    (size_t)cols * sizeof(schar_T));
  #endif
  	}
  
  	update_screen(0);
  	ret = 3;
  
  	if (must_redraw == 0)
  	{
  	    int	off = (int)(current_ScreenLine - ScreenLines);
  
  	    /* Restore the text displayed in the command line area. */
  	    for (r = 0; r < rows; ++r)
  	    {
  		mch_memmove(current_ScreenLine,
  			    screenline + r * cols,
  			    (size_t)cols * sizeof(schar_T));
  		mch_memmove(ScreenAttrs + off,
  			    screenattr + r * cols,
  			    (size_t)cols * sizeof(sattr_T));
  #ifdef FEAT_MBYTE
  		if (enc_utf8)
  		{
  		    mch_memmove(ScreenLinesUC + off,
  				screenlineUC + r * cols,
  				(size_t)cols * sizeof(u8char_T));
  		    for (i = 0; i < p_mco; ++i)
  			mch_memmove(ScreenLinesC[i] + off,
  				    screenlineC[i] + r * cols,
  				    (size_t)cols * sizeof(u8char_T));
  		}
  		if (enc_dbcs == DBCS_JPNU)
  		    mch_memmove(ScreenLines2 + off,
  				screenline2 + r * cols,
  				(size_t)cols * sizeof(schar_T));
  #endif
  		screen_line(cmdline_row + r, 0, cols, cols, FALSE);
  	    }
  	    ret = 4;
  	}
      }
  
      vim_free(screenline);
      vim_free(screenattr);
  #ifdef FEAT_MBYTE
      if (enc_utf8)
      {
  	vim_free(screenlineUC);
  	for (i = 0; i < p_mco; ++i)
  	    vim_free(screenlineC[i]);
      }
      if (enc_dbcs == DBCS_JPNU)
  	vim_free(screenline2);
  #endif
  
      /* Show the intro message when appropriate. */
      maybe_intro_message();
  
      setcursor();
  
      return ret;
  }
  
  /*
   * Invoked after an asynchronous callback is called.
   * If an echo command was used the cursor needs to be put back where
   * it belongs. If highlighting was changed a redraw is needed.
   * If "call_update_screen" is FALSE don't call update_screen() when at the
   * command line.
   */
      void
  redraw_after_callback(int call_update_screen)
  {
      ++redrawing_for_callback;
  
      if (State == HITRETURN || State == ASKMORE)
  	; /* do nothing */
      else if (State & CMDLINE)
      {
  	/* Redrawing only works when the screen didn't scroll. Don't clear
  	 * wildmenu entries. */
  	if (msg_scrolled == 0
  #ifdef FEAT_WILDMENU
  		&& wild_menu_showing == 0
  #endif
  		&& call_update_screen)
  	    update_screen(0);
  	/* Redraw in the same position, so that the user can continue
  	 * editing the command. */
  	redrawcmdline_ex(FALSE);
      }
      else if (State & (NORMAL | INSERT | TERMINAL))
      {
  	/* keep the command line if possible */
  	update_screen(VALID_NO_UPDATE);
  	setcursor();
      }
      cursor_on();
  #ifdef FEAT_GUI
      if (gui.in_use && !gui_mch_is_blink_off())
  	/* Don't update the cursor when it is blinking and off to avoid
  	 * flicker. */
  	out_flush_cursor(FALSE, FALSE);
      else
  #endif
  	out_flush();
  
      --redrawing_for_callback;
  }
  
  /*
   * Changed something in the current window, at buffer line "lnum", that
   * requires that line and possibly other lines to be redrawn.
   * Used when entering/leaving Insert mode with the cursor on a folded line.
   * Used to remove the "$" from a change command.
   * Note that when also inserting/deleting lines w_redraw_top and w_redraw_bot
   * may become invalid and the whole window will have to be redrawn.
   */
      void
  redrawWinline(
      linenr_T	lnum,
      int		invalid UNUSED)	/* window line height is invalid now */
  {
  #ifdef FEAT_FOLDING
      int		i;
  #endif
  
      if (curwin->w_redraw_top == 0 || curwin->w_redraw_top > lnum)
  	curwin->w_redraw_top = lnum;
      if (curwin->w_redraw_bot == 0 || curwin->w_redraw_bot < lnum)
  	curwin->w_redraw_bot = lnum;
      redraw_later(VALID);
  
  #ifdef FEAT_FOLDING
      if (invalid)
      {
  	/* A w_lines[] entry for this lnum has become invalid. */
  	i = find_wl_entry(curwin, lnum);
  	if (i >= 0)
  	    curwin->w_lines[i].wl_valid = FALSE;
      }
  #endif
  }
  
  /*
   * Update all windows that are editing the current buffer.
   */
      void
  update_curbuf(int type)
  {
      redraw_curbuf_later(type);
      update_screen(type);
  }
  
  /*
   * Based on the current value of curwin->w_topline, transfer a screenfull
   * of stuff from Filemem to ScreenLines[], and update curwin->w_botline.
   * Return OK when the screen was updated, FAIL if it was not done.
   */
      int
  update_screen(int type_arg)
  {
      int		type = type_arg;
      win_T	*wp;
      static int	did_intro = FALSE;
  #if defined(FEAT_SEARCH_EXTRA) || defined(FEAT_CLIPBOARD)
      int		did_one;
  #endif
  #ifdef FEAT_GUI
      int		did_undraw = FALSE;
      int		gui_cursor_col;
      int		gui_cursor_row;
  #endif
      int		no_update = FALSE;
  
      /* Don't do anything if the screen structures are (not yet) valid. */
      if (!screen_valid(TRUE))
  	return FAIL;
  
      if (type == VALID_NO_UPDATE)
      {
  	no_update = TRUE;
  	type = 0;
      }
  
      if (must_redraw)
      {
  	if (type < must_redraw)	    /* use maximal type */
  	    type = must_redraw;
  
  	/* must_redraw is reset here, so that when we run into some weird
  	 * reason to redraw while busy redrawing (e.g., asynchronous
  	 * scrolling), or update_topline() in win_update() will cause a
  	 * scroll, the screen will be redrawn later or in win_update(). */
  	must_redraw = 0;
      }
  
      /* Need to update w_lines[]. */
      if (curwin->w_lines_valid == 0 && type < NOT_VALID)
  	type = NOT_VALID;
  
      /* Postpone the redrawing when it's not needed and when being called
       * recursively. */
      if (!redrawing() || updating_screen)
      {
  	redraw_later(type);		/* remember type for next time */
  	must_redraw = type;
  	if (type > INVERTED_ALL)
  	    curwin->w_lines_valid = 0;	/* don't use w_lines[].wl_size now */
  	return FAIL;
      }
  
      updating_screen = TRUE;
  #ifdef FEAT_SYN_HL
      ++display_tick;	    /* let syntax code know we're in a next round of
  			     * display updating */
  #endif
      if (no_update)
  	++no_win_do_lines_ins;
  
      /*
       * if the screen was scrolled up when displaying a message, scroll it down
       */
      if (msg_scrolled)
      {
  	clear_cmdline = TRUE;
  	if (msg_scrolled > Rows - 5)	    /* clearing is faster */
  	    type = CLEAR;
  	else if (type != CLEAR)
  	{
  	    check_for_delay(FALSE);
  	    if (screen_ins_lines(0, 0, msg_scrolled, (int)Rows, 0, NULL)
  								       == FAIL)
  		type = CLEAR;
  	    FOR_ALL_WINDOWS(wp)
  	    {
  		if (W_WINROW(wp) < msg_scrolled)
  		{
  		    if (W_WINROW(wp) + wp->w_height > msg_scrolled
  			    && wp->w_redr_type < REDRAW_TOP
  			    && wp->w_lines_valid > 0
  			    && wp->w_topline == wp->w_lines[0].wl_lnum)
  		    {
  			wp->w_upd_rows = msg_scrolled - W_WINROW(wp);
  			wp->w_redr_type = REDRAW_TOP;
  		    }
  		    else
  		    {
  			wp->w_redr_type = NOT_VALID;
  			if (W_WINROW(wp) + wp->w_height + wp->w_status_height
  							       <= msg_scrolled)
  			    wp->w_redr_status = TRUE;
  		    }
  		}
  	    }
  	    if (!no_update)
  		redraw_cmdline = TRUE;
  	    redraw_tabline = TRUE;
  	}
  	msg_scrolled = 0;
  	need_wait_return = FALSE;
      }
  
      /* reset cmdline_row now (may have been changed temporarily) */
      compute_cmdrow();
  
      /* Check for changed highlighting */
      if (need_highlight_changed)
  	highlight_changed();
  
      if (type == CLEAR)		/* first clear screen */
      {
  	screenclear();		/* will reset clear_cmdline */
  	type = NOT_VALID;
  	/* must_redraw may be set indirectly, avoid another redraw later */
  	must_redraw = 0;
      }
  
      if (clear_cmdline)		/* going to clear cmdline (done below) */
  	check_for_delay(FALSE);
  
  #ifdef FEAT_LINEBREAK
      /* Force redraw when width of 'number' or 'relativenumber' column
       * changes. */
      if (curwin->w_redr_type < NOT_VALID
  	   && curwin->w_nrwidth != ((curwin->w_p_nu || curwin->w_p_rnu)
  				    ? number_width(curwin) : 0))
  	curwin->w_redr_type = NOT_VALID;
  #endif
  
      /*
       * Only start redrawing if there is really something to do.
       */
      if (type == INVERTED)
  	update_curswant();
      if (curwin->w_redr_type < type
  	    && !((type == VALID
  		    && curwin->w_lines[0].wl_valid
  #ifdef FEAT_DIFF
  		    && curwin->w_topfill == curwin->w_old_topfill
  		    && curwin->w_botfill == curwin->w_old_botfill
  #endif
  		    && curwin->w_topline == curwin->w_lines[0].wl_lnum)
  		|| (type == INVERTED
  		    && VIsual_active
  		    && curwin->w_old_cursor_lnum == curwin->w_cursor.lnum
  		    && curwin->w_old_visual_mode == VIsual_mode
  		    && (curwin->w_valid & VALID_VIRTCOL)
  		    && curwin->w_old_curswant == curwin->w_curswant)
  		))
  	curwin->w_redr_type = type;
  
      /* Redraw the tab pages line if needed. */
      if (redraw_tabline || type >= NOT_VALID)
  	draw_tabline();
  
  #ifdef FEAT_SYN_HL
      /*
       * Correct stored syntax highlighting info for changes in each displayed
       * buffer.  Each buffer must only be done once.
       */
      FOR_ALL_WINDOWS(wp)
      {
  	if (wp->w_buffer->b_mod_set)
  	{
  	    win_T	*wwp;
  
  	    /* Check if we already did this buffer. */
  	    for (wwp = firstwin; wwp != wp; wwp = wwp->w_next)
  		if (wwp->w_buffer == wp->w_buffer)
  		    break;
  	    if (wwp == wp && syntax_present(wp))
  		syn_stack_apply_changes(wp->w_buffer);
  	}
      }
  #endif
  
      /*
       * Go from top to bottom through the windows, redrawing the ones that need
       * it.
       */
  #if defined(FEAT_SEARCH_EXTRA) || defined(FEAT_CLIPBOARD)
      did_one = FALSE;
  #endif
  #ifdef FEAT_SEARCH_EXTRA
      search_hl.rm.regprog = NULL;
  #endif
      FOR_ALL_WINDOWS(wp)
      {
  	if (wp->w_redr_type != 0)
  	{
  	    cursor_off();
  #if defined(FEAT_SEARCH_EXTRA) || defined(FEAT_CLIPBOARD)
  	    if (!did_one)
  	    {
  		did_one = TRUE;
  # ifdef FEAT_SEARCH_EXTRA
  		start_search_hl();
  # endif
  # ifdef FEAT_CLIPBOARD
  		/* When Visual area changed, may have to update selection. */
  		if (clip_star.available && clip_isautosel_star())
  		    clip_update_selection(&clip_star);
  		if (clip_plus.available && clip_isautosel_plus())
  		    clip_update_selection(&clip_plus);
  # endif
  #ifdef FEAT_GUI
  		/* Remove the cursor before starting to do anything, because
  		 * scrolling may make it difficult to redraw the text under
  		 * it. */
  		if (gui.in_use && wp == curwin)
  		{
  		    gui_cursor_col = gui.cursor_col;
  		    gui_cursor_row = gui.cursor_row;
  		    gui_undraw_cursor();
  		    did_undraw = TRUE;
  		}
  #endif
  	    }
  #endif
  	    win_update(wp);
  	}
  
  	/* redraw status line after the window to minimize cursor movement */
  	if (wp->w_redr_status)
  	{
  	    cursor_off();
  	    win_redr_status(wp);
  	}
      }
  #if defined(FEAT_SEARCH_EXTRA)
      end_search_hl();
  #endif
  #ifdef FEAT_INS_EXPAND
      /* May need to redraw the popup menu. */
      if (pum_visible())
  	pum_redraw();
  #endif
  
      /* Reset b_mod_set flags.  Going through all windows is probably faster
       * than going through all buffers (there could be many buffers). */
      FOR_ALL_WINDOWS(wp)
  	wp->w_buffer->b_mod_set = FALSE;
  
      updating_screen = FALSE;
  #ifdef FEAT_GUI
      gui_may_resize_shell();
  #endif
  
      /* Clear or redraw the command line.  Done last, because scrolling may
       * mess up the command line. */
      if (clear_cmdline || redraw_cmdline)
  	showmode();
  
      if (no_update)
  	--no_win_do_lines_ins;
  
      /* May put up an introductory message when not editing a file */
      if (!did_intro)
  	maybe_intro_message();
      did_intro = TRUE;
  
  #ifdef FEAT_GUI
      /* Redraw the cursor and update the scrollbars when all screen updating is
       * done. */
      if (gui.in_use)
      {
  	if (did_undraw && !gui_mch_is_blink_off())
  	{
  	    mch_disable_flush();
  	    out_flush();	/* required before updating the cursor */
  	    mch_enable_flush();
  
  	    /* Put the GUI position where the cursor was, gui_update_cursor()
  	     * uses that. */
  	    gui.col = gui_cursor_col;
  	    gui.row = gui_cursor_row;
  # ifdef FEAT_MBYTE
  	    gui.col = mb_fix_col(gui.col, gui.row);
  # endif
  	    gui_update_cursor(FALSE, FALSE);
  	    gui_may_flush();
  	    screen_cur_col = gui.col;
  	    screen_cur_row = gui.row;
  	}
  	else
  	    out_flush();
  	gui_update_scrollbars(FALSE);
      }
  #endif
      return OK;
  }
  
  #if defined(FEAT_SIGNS) || defined(FEAT_GUI) || defined(FEAT_CONCEAL)
  /*
   * Prepare for updating one or more windows.
   * Caller must check for "updating_screen" already set to avoid recursiveness.
   */
      static void
  update_prepare(void)
  {
      cursor_off();
      updating_screen = TRUE;
  #ifdef FEAT_GUI
      /* Remove the cursor before starting to do anything, because scrolling may
       * make it difficult to redraw the text under it. */
      if (gui.in_use)
  	gui_undraw_cursor();
  #endif
  #ifdef FEAT_SEARCH_EXTRA
      start_search_hl();
  #endif
  }
  
  /*
   * Finish updating one or more windows.
   */
      static void
  update_finish(void)
  {
      if (redraw_cmdline)
  	showmode();
  
  # ifdef FEAT_SEARCH_EXTRA
      end_search_hl();
  # endif
  
      updating_screen = FALSE;
  
  # ifdef FEAT_GUI
      gui_may_resize_shell();
  
      /* Redraw the cursor and update the scrollbars when all screen updating is
       * done. */
      if (gui.in_use)
      {
  	out_flush_cursor(FALSE, FALSE);
  	gui_update_scrollbars(FALSE);
      }
  # endif
  }
  #endif
  
  #if defined(FEAT_CONCEAL) || defined(PROTO)
  /*
   * Return TRUE if the cursor line in window "wp" may be concealed, according
   * to the 'concealcursor' option.
   */
      int
  conceal_cursor_line(win_T *wp)
  {
      int		c;
  
      if (*wp->w_p_cocu == NUL)
  	return FALSE;
      if (get_real_state() & VISUAL)
  	c = 'v';
      else if (State & INSERT)
  	c = 'i';
      else if (State & NORMAL)
  	c = 'n';
      else if (State & CMDLINE)
  	c = 'c';
      else
  	return FALSE;
      return vim_strchr(wp->w_p_cocu, c) != NULL;
  }
  
  /*
   * Check if the cursor line needs to be redrawn because of 'concealcursor'.
   */
      void
  conceal_check_cursur_line(void)
  {
      if (curwin->w_p_cole > 0 && conceal_cursor_line(curwin))
      {
  	need_cursor_line_redraw = TRUE;
  	/* Need to recompute cursor column, e.g., when starting Visual mode
  	 * without concealing. */
  	curs_columns(TRUE);
      }
  }
  
      void
  update_single_line(win_T *wp, linenr_T lnum)
  {
      int		row;
      int		j;
  #ifdef SYN_TIME_LIMIT
      proftime_T	syntax_tm;
  #endif
  
      /* Don't do anything if the screen structures are (not yet) valid. */
      if (!screen_valid(TRUE) || updating_screen)
  	return;
  
      if (lnum >= wp->w_topline && lnum < wp->w_botline
  				 && foldedCount(wp, lnum, &win_foldinfo) == 0)
      {
  #ifdef SYN_TIME_LIMIT
  	/* Set the time limit to 'redrawtime'. */
  	profile_setlimit(p_rdt, &syntax_tm);
  	syn_set_timeout(&syntax_tm);
  #endif
  	update_prepare();
  
  	row = 0;
  	for (j = 0; j < wp->w_lines_valid; ++j)
  	{
  	    if (lnum == wp->w_lines[j].wl_lnum)
  	    {
  		screen_start();	/* not sure of screen cursor */
  # ifdef FEAT_SEARCH_EXTRA
  		init_search_hl(wp);
  		start_search_hl();
  		prepare_search_hl(wp, lnum);
  # endif
  		win_line(wp, lnum, row, row + wp->w_lines[j].wl_size, FALSE);
  # if defined(FEAT_SEARCH_EXTRA)
  		end_search_hl();
  # endif
  		break;
  	    }
  	    row += wp->w_lines[j].wl_size;
  	}
  
  	update_finish();
  
  #ifdef SYN_TIME_LIMIT
  	syn_set_timeout(NULL);
  #endif
      }
      need_cursor_line_redraw = FALSE;
  }
  #endif
  
  #if defined(FEAT_SIGNS) || defined(PROTO)
      void
  update_debug_sign(buf_T *buf, linenr_T lnum)
  {
      win_T	*wp;
      int		doit = FALSE;
  
  # ifdef FEAT_FOLDING
      win_foldinfo.fi_level = 0;
  # endif
  
      /* update/delete a specific mark */
      FOR_ALL_WINDOWS(wp)
      {
  	if (buf != NULL && lnum > 0)
  	{
  	    if (wp->w_buffer == buf && lnum >= wp->w_topline
  						      && lnum < wp->w_botline)
  	    {
  		if (wp->w_redraw_top == 0 || wp->w_redraw_top > lnum)
  		    wp->w_redraw_top = lnum;
  		if (wp->w_redraw_bot == 0 || wp->w_redraw_bot < lnum)
  		    wp->w_redraw_bot = lnum;
  		redraw_win_later(wp, VALID);
  	    }
  	}
  	else
  	    redraw_win_later(wp, VALID);
  	if (wp->w_redr_type != 0)
  	    doit = TRUE;
      }
  
      /* Return when there is nothing to do, screen updating is already
       * happening (recursive call), messages on the screen or still starting up.
       */
      if (!doit || updating_screen
  	    || State == ASKMORE || State == HITRETURN
  	    || msg_scrolled
  #ifdef FEAT_GUI
  	    || gui.starting
  #endif
  	    || starting)
  	return;
  
      /* update all windows that need updating */
      update_prepare();
  
      FOR_ALL_WINDOWS(wp)
      {
  	if (wp->w_redr_type != 0)
  	    win_update(wp);
  	if (wp->w_redr_status)
  	    win_redr_status(wp);
      }
  
      update_finish();
  }
  #endif
  
  
  #if defined(FEAT_GUI) || defined(PROTO)
  /*
   * Update a single window, its status line and maybe the command line msg.
   * Used for the GUI scrollbar.
   */
      void
  updateWindow(win_T *wp)
  {
      /* return if already busy updating */
      if (updating_screen)
  	return;
  
      update_prepare();
  
  #ifdef FEAT_CLIPBOARD
      /* When Visual area changed, may have to update selection. */
      if (clip_star.available && clip_isautosel_star())
  	clip_update_selection(&clip_star);
      if (clip_plus.available && clip_isautosel_plus())
  	clip_update_selection(&clip_plus);
  #endif
  
      win_update(wp);
  
      /* When the screen was cleared redraw the tab pages line. */
      if (redraw_tabline)
  	draw_tabline();
  
      if (wp->w_redr_status
  # ifdef FEAT_CMDL_INFO
  	    || p_ru
  # endif
  # ifdef FEAT_STL_OPT
  	    || *p_stl != NUL || *wp->w_p_stl != NUL
  # endif
  	    )
  	win_redr_status(wp);
  
      update_finish();
  }
  #endif
  
  /*
   * Update a single window.
   *
   * This may cause the windows below it also to be redrawn (when clearing the
   * screen or scrolling lines).
   *
   * How the window is redrawn depends on wp->w_redr_type.  Each type also
   * implies the one below it.
   * NOT_VALID	redraw the whole window
   * SOME_VALID	redraw the whole window but do scroll when possible
   * REDRAW_TOP	redraw the top w_upd_rows window lines, otherwise like VALID
   * INVERTED	redraw the changed part of the Visual area
   * INVERTED_ALL	redraw the whole Visual area
   * VALID	1. scroll up/down to adjust for a changed w_topline
   *		2. update lines at the top when scrolled down
   *		3. redraw changed text:
   *		   - if wp->w_buffer->b_mod_set set, update lines between
   *		     b_mod_top and b_mod_bot.
   *		   - if wp->w_redraw_top non-zero, redraw lines between
   *		     wp->w_redraw_top and wp->w_redr_bot.
   *		   - continue redrawing when syntax status is invalid.
   *		4. if scrolled up, update lines at the bottom.
   * This results in three areas that may need updating:
   * top:	from first row to top_end (when scrolled down)
   * mid: from mid_start to mid_end (update inversion or changed text)
   * bot: from bot_start to last row (when scrolled up)
   */
      static void
  win_update(win_T *wp)
  {
      buf_T	*buf = wp->w_buffer;
      int		type;
      int		top_end = 0;	/* Below last row of the top area that needs
  				   updating.  0 when no top area updating. */
      int		mid_start = 999;/* first row of the mid area that needs
  				   updating.  999 when no mid area updating. */
      int		mid_end = 0;	/* Below last row of the mid area that needs
  				   updating.  0 when no mid area updating. */
      int		bot_start = 999;/* first row of the bot area that needs
  				   updating.  999 when no bot area updating */
      int		scrolled_down = FALSE;	/* TRUE when scrolled down when
  					   w_topline got smaller a bit */
  #ifdef FEAT_SEARCH_EXTRA
      matchitem_T *cur;		/* points to the match list */
      int		top_to_mod = FALSE;    /* redraw above mod_top */
  #endif
  
      int		row;		/* current window row to display */
      linenr_T	lnum;		/* current buffer lnum to display */
      int		idx;		/* current index in w_lines[] */
      int		srow;		/* starting row of the current line */
  
      int		eof = FALSE;	/* if TRUE, we hit the end of the file */
      int		didline = FALSE; /* if TRUE, we finished the last line */
      int		i;
      long	j;
      static int	recursive = FALSE;	/* being called recursively */
      int		old_botline = wp->w_botline;
  #ifdef FEAT_FOLDING
      long	fold_count;
  #endif
  #ifdef FEAT_SYN_HL
      /* remember what happened to the previous line, to know if
       * check_visual_highlight() can be used */
  #define DID_NONE 1	/* didn't update a line */
  #define DID_LINE 2	/* updated a normal line */
  #define DID_FOLD 3	/* updated a folded line */
      int		did_update = DID_NONE;
      linenr_T	syntax_last_parsed = 0;		/* last parsed text line */
  #endif
      linenr_T	mod_top = 0;
      linenr_T	mod_bot = 0;
  #if defined(FEAT_SYN_HL) || defined(FEAT_SEARCH_EXTRA)
      int		save_got_int;
  #endif
  #ifdef SYN_TIME_LIMIT
      proftime_T	syntax_tm;
  #endif
  
      type = wp->w_redr_type;
  
      if (type == NOT_VALID)
      {
  	wp->w_redr_status = TRUE;
  	wp->w_lines_valid = 0;
      }
  
      /* Window is zero-height: nothing to draw. */
      if (wp->w_height + WINBAR_HEIGHT(wp) == 0)
      {
  	wp->w_redr_type = 0;
  	return;
      }
  
      /* Window is zero-width: Only need to draw the separator. */
      if (wp->w_width == 0)
      {
  	/* draw the vertical separator right of this window */
  	draw_vsep_win(wp, 0);
  	wp->w_redr_type = 0;
  	return;
      }
  
  #ifdef FEAT_TERMINAL
      /* If this window contains a terminal, redraw works completely differently.
       */
      if (term_update_window(wp) == OK)
      {
  # ifdef FEAT_MENU
  	/* Draw the window toolbar, if there is one. */
  	if (winbar_height(wp) > 0)
  	    redraw_win_toolbar(wp);
  # endif
  	wp->w_redr_type = 0;
  	return;
      }
  #endif
  
  #ifdef FEAT_SEARCH_EXTRA
      init_search_hl(wp);
  #endif
  
  #ifdef FEAT_LINEBREAK
      /* Force redraw when width of 'number' or 'relativenumber' column
       * changes. */
      i = (wp->w_p_nu || wp->w_p_rnu) ? number_width(wp) : 0;
      if (wp->w_nrwidth != i)
      {
  	type = NOT_VALID;
  	wp->w_nrwidth = i;
      }
      else
  #endif
  
      if (buf->b_mod_set && buf->b_mod_xlines != 0 && wp->w_redraw_top != 0)
      {
  	/*
  	 * When there are both inserted/deleted lines and specific lines to be
  	 * redrawn, w_redraw_top and w_redraw_bot may be invalid, just redraw
  	 * everything (only happens when redrawing is off for while).
  	 */
  	type = NOT_VALID;
      }
      else
      {
  	/*
  	 * Set mod_top to the first line that needs displaying because of
  	 * changes.  Set mod_bot to the first line after the changes.
  	 */
  	mod_top = wp->w_redraw_top;
  	if (wp->w_redraw_bot != 0)
  	    mod_bot = wp->w_redraw_bot + 1;
  	else
  	    mod_bot = 0;
  	wp->w_redraw_top = 0;	/* reset for next time */
  	wp->w_redraw_bot = 0;
  	if (buf->b_mod_set)
  	{
  	    if (mod_top == 0 || mod_top > buf->b_mod_top)
  	    {
  		mod_top = buf->b_mod_top;
  #ifdef FEAT_SYN_HL
  		/* Need to redraw lines above the change that may be included
  		 * in a pattern match. */
  		if (syntax_present(wp))
  		{
  		    mod_top -= buf->b_s.b_syn_sync_linebreaks;
  		    if (mod_top < 1)
  			mod_top = 1;
  		}
  #endif
  	    }
  	    if (mod_bot == 0 || mod_bot < buf->b_mod_bot)
  		mod_bot = buf->b_mod_bot;
  
  #ifdef FEAT_SEARCH_EXTRA
  	    /* When 'hlsearch' is on and using a multi-line search pattern, a
  	     * change in one line may make the Search highlighting in a
  	     * previous line invalid.  Simple solution: redraw all visible
  	     * lines above the change.
  	     * Same for a match pattern.
  	     */
  	    if (search_hl.rm.regprog != NULL
  					&& re_multiline(search_hl.rm.regprog))
  		top_to_mod = TRUE;
  	    else
  	    {
  		cur = wp->w_match_head;
  		while (cur != NULL)
  		{
  		    if (cur->match.regprog != NULL
  					   && re_multiline(cur->match.regprog))
  		    {
  			top_to_mod = TRUE;
  			break;
  		    }
  		    cur = cur->next;
  		}
  	    }
  #endif
  	}
  #ifdef FEAT_FOLDING
  	if (mod_top != 0 && hasAnyFolding(wp))
  	{
  	    linenr_T	lnumt, lnumb;
  
  	    /*
  	     * A change in a line can cause lines above it to become folded or
  	     * unfolded.  Find the top most buffer line that may be affected.
  	     * If the line was previously folded and displayed, get the first
  	     * line of that fold.  If the line is folded now, get the first
  	     * folded line.  Use the minimum of these two.
  	     */
  
  	    /* Find last valid w_lines[] entry above mod_top.  Set lnumt to
  	     * the line below it.  If there is no valid entry, use w_topline.
  	     * Find the first valid w_lines[] entry below mod_bot.  Set lnumb
  	     * to this line.  If there is no valid entry, use MAXLNUM. */
  	    lnumt = wp->w_topline;
  	    lnumb = MAXLNUM;
  	    for (i = 0; i < wp->w_lines_valid; ++i)
  		if (wp->w_lines[i].wl_valid)
  		{
  		    if (wp->w_lines[i].wl_lastlnum < mod_top)
  			lnumt = wp->w_lines[i].wl_lastlnum + 1;
  		    if (lnumb == MAXLNUM && wp->w_lines[i].wl_lnum >= mod_bot)
  		    {
  			lnumb = wp->w_lines[i].wl_lnum;
  			/* When there is a fold column it might need updating
  			 * in the next line ("J" just above an open fold). */
  			if (compute_foldcolumn(wp, 0) > 0)
  			    ++lnumb;
  		    }
  		}
  
  	    (void)hasFoldingWin(wp, mod_top, &mod_top, NULL, TRUE, NULL);
  	    if (mod_top > lnumt)
  		mod_top = lnumt;
  
  	    /* Now do the same for the bottom line (one above mod_bot). */
  	    --mod_bot;
  	    (void)hasFoldingWin(wp, mod_bot, NULL, &mod_bot, TRUE, NULL);
  	    ++mod_bot;
  	    if (mod_bot < lnumb)
  		mod_bot = lnumb;
  	}
  #endif
  
  	/* When a change starts above w_topline and the end is below
  	 * w_topline, start redrawing at w_topline.
  	 * If the end of the change is above w_topline: do like no change was
  	 * made, but redraw the first line to find changes in syntax. */
  	if (mod_top != 0 && mod_top < wp->w_topline)
  	{
  	    if (mod_bot > wp->w_topline)
  		mod_top = wp->w_topline;
  #ifdef FEAT_SYN_HL
  	    else if (syntax_present(wp))
  		top_end = 1;
  #endif
  	}
  
  	/* When line numbers are displayed need to redraw all lines below
  	 * inserted/deleted lines. */
  	if (mod_top != 0 && buf->b_mod_xlines != 0 && wp->w_p_nu)
  	    mod_bot = MAXLNUM;
      }
  
      /*
       * When only displaying the lines at the top, set top_end.  Used when
       * window has scrolled down for msg_scrolled.
       */
      if (type == REDRAW_TOP)
      {
  	j = 0;
  	for (i = 0; i < wp->w_lines_valid; ++i)
  	{
  	    j += wp->w_lines[i].wl_size;
  	    if (j >= wp->w_upd_rows)
  	    {
  		top_end = j;
  		break;
  	    }
  	}
  	if (top_end == 0)
  	    /* not found (cannot happen?): redraw everything */
  	    type = NOT_VALID;
  	else
  	    /* top area defined, the rest is VALID */
  	    type = VALID;
      }
  
      /* Trick: we want to avoid clearing the screen twice.  screenclear() will
       * set "screen_cleared" to TRUE.  The special value MAYBE (which is still
       * non-zero and thus not FALSE) will indicate that screenclear() was not
       * called. */
      if (screen_cleared)
  	screen_cleared = MAYBE;
  
      /*
       * If there are no changes on the screen that require a complete redraw,
       * handle three cases:
       * 1: we are off the top of the screen by a few lines: scroll down
       * 2: wp->w_topline is below wp->w_lines[0].wl_lnum: may scroll up
       * 3: wp->w_topline is wp->w_lines[0].wl_lnum: find first entry in
       *    w_lines[] that needs updating.
       */
      if ((type == VALID || type == SOME_VALID
  				  || type == INVERTED || type == INVERTED_ALL)
  #ifdef FEAT_DIFF
  	    && !wp->w_botfill && !wp->w_old_botfill
  #endif
  	    )
      {
  	if (mod_top != 0 && wp->w_topline == mod_top)
  	{
  	    /*
  	     * w_topline is the first changed line, the scrolling will be done
  	     * further down.
  	     */
  	}
  	else if (wp->w_lines[0].wl_valid
  		&& (wp->w_topline < wp->w_lines[0].wl_lnum
  #ifdef FEAT_DIFF
  		    || (wp->w_topline == wp->w_lines[0].wl_lnum
  			&& wp->w_topfill > wp->w_old_topfill)
  #endif
  		   ))
  	{
  	    /*
  	     * New topline is above old topline: May scroll down.
  	     */
  #ifdef FEAT_FOLDING
  	    if (hasAnyFolding(wp))
  	    {
  		linenr_T ln;
  
  		/* count the number of lines we are off, counting a sequence
  		 * of folded lines as one */
  		j = 0;
  		for (ln = wp->w_topline; ln < wp->w_lines[0].wl_lnum; ++ln)
  		{
  		    ++j;
  		    if (j >= wp->w_height - 2)
  			break;
  		    (void)hasFoldingWin(wp, ln, NULL, &ln, TRUE, NULL);
  		}
  	    }
  	    else
  #endif
  		j = wp->w_lines[0].wl_lnum - wp->w_topline;
  	    if (j < wp->w_height - 2)		/* not too far off */
  	    {
  		i = plines_m_win(wp, wp->w_topline, wp->w_lines[0].wl_lnum - 1);
  #ifdef FEAT_DIFF
  		/* insert extra lines for previously invisible filler lines */
  		if (wp->w_lines[0].wl_lnum != wp->w_topline)
  		    i += diff_check_fill(wp, wp->w_lines[0].wl_lnum)
  							  - wp->w_old_topfill;
  #endif
  		if (i < wp->w_height - 2)	/* less than a screen off */
  		{
  		    /*
  		     * Try to insert the correct number of lines.
  		     * If not the last window, delete the lines at the bottom.
  		     * win_ins_lines may fail when the terminal can't do it.
  		     */
  		    if (i > 0)
  			check_for_delay(FALSE);
  		    if (win_ins_lines(wp, 0, i, FALSE, wp == firstwin) == OK)
  		    {
  			if (wp->w_lines_valid != 0)
  			{
  			    /* Need to update rows that are new, stop at the
  			     * first one that scrolled down. */
  			    top_end = i;
  			    scrolled_down = TRUE;
  
  			    /* Move the entries that were scrolled, disable
  			     * the entries for the lines to be redrawn. */
  			    if ((wp->w_lines_valid += j) > wp->w_height)
  				wp->w_lines_valid = wp->w_height;
  			    for (idx = wp->w_lines_valid; idx - j >= 0; idx--)
  				wp->w_lines[idx] = wp->w_lines[idx - j];
  			    while (idx >= 0)
  				wp->w_lines[idx--].wl_valid = FALSE;
  			}
  		    }
  		    else
  			mid_start = 0;		/* redraw all lines */
  		}
  		else
  		    mid_start = 0;		/* redraw all lines */
  	    }
  	    else
  		mid_start = 0;		/* redraw all lines */
  	}
  	else
  	{
  	    /*
  	     * New topline is at or below old topline: May scroll up.
  	     * When topline didn't change, find first entry in w_lines[] that
  	     * needs updating.
  	     */
  
  	    /* try to find wp->w_topline in wp->w_lines[].wl_lnum */
  	    j = -1;
  	    row = 0;
  	    for (i = 0; i < wp->w_lines_valid; i++)
  	    {
  		if (wp->w_lines[i].wl_valid
  			&& wp->w_lines[i].wl_lnum == wp->w_topline)
  		{
  		    j = i;
  		    break;
  		}
  		row += wp->w_lines[i].wl_size;
  	    }
  	    if (j == -1)
  	    {
  		/* if wp->w_topline is not in wp->w_lines[].wl_lnum redraw all
  		 * lines */
  		mid_start = 0;
  	    }
  	    else
  	    {
  		/*
  		 * Try to delete the correct number of lines.
  		 * wp->w_topline is at wp->w_lines[i].wl_lnum.
  		 */
  #ifdef FEAT_DIFF
  		/* If the topline didn't change, delete old filler lines,
  		 * otherwise delete filler lines of the new topline... */
  		if (wp->w_lines[0].wl_lnum == wp->w_topline)
  		    row += wp->w_old_topfill;
  		else
  		    row += diff_check_fill(wp, wp->w_topline);
  		/* ... but don't delete new filler lines. */
  		row -= wp->w_topfill;
  #endif
  		if (row > 0)
  		{
  		    check_for_delay(FALSE);
  		    if (win_del_lines(wp, 0, row, FALSE, wp == firstwin, 0)
  									 == OK)
  			bot_start = wp->w_height - row;
  		    else
  			mid_start = 0;		/* redraw all lines */
  		}
  		if ((row == 0 || bot_start < 999) && wp->w_lines_valid != 0)
  		{
  		    /*
  		     * Skip the lines (below the deleted lines) that are still
  		     * valid and don't need redrawing.	Copy their info
  		     * upwards, to compensate for the deleted lines.  Set
  		     * bot_start to the first row that needs redrawing.
  		     */
  		    bot_start = 0;
  		    idx = 0;
  		    for (;;)
  		    {
  			wp->w_lines[idx] = wp->w_lines[j];
  			/* stop at line that didn't fit, unless it is still
  			 * valid (no lines deleted) */
  			if (row > 0 && bot_start + row
  				 + (int)wp->w_lines[j].wl_size > wp->w_height)
  			{
  			    wp->w_lines_valid = idx + 1;
  			    break;
  			}
  			bot_start += wp->w_lines[idx++].wl_size;
  
  			/* stop at the last valid entry in w_lines[].wl_size */
  			if (++j >= wp->w_lines_valid)
  			{
  			    wp->w_lines_valid = idx;
  			    break;
  			}
  		    }
  #ifdef FEAT_DIFF
  		    /* Correct the first entry for filler lines at the top
  		     * when it won't get updated below. */
  		    if (wp->w_p_diff && bot_start > 0)
  			wp->w_lines[0].wl_size =
  			    plines_win_nofill(wp, wp->w_topline, TRUE)
  							      + wp->w_topfill;
  #endif
  		}
  	    }
  	}
  
  	/* When starting redraw in the first line, redraw all lines.  When
  	 * there is only one window it's probably faster to clear the screen
  	 * first. */
  	if (mid_start == 0)
  	{
  	    mid_end = wp->w_height;
  	    if (ONE_WINDOW)
  	    {
  		/* Clear the screen when it was not done by win_del_lines() or
  		 * win_ins_lines() above, "screen_cleared" is FALSE or MAYBE
  		 * then. */
  		if (screen_cleared != TRUE)
  		    screenclear();
  		/* The screen was cleared, redraw the tab pages line. */
  		if (redraw_tabline)
  		    draw_tabline();
  	    }
  	}
  
  	/* When win_del_lines() or win_ins_lines() caused the screen to be
  	 * cleared (only happens for the first window) or when screenclear()
  	 * was called directly above, "must_redraw" will have been set to
  	 * NOT_VALID, need to reset it here to avoid redrawing twice. */
  	if (screen_cleared == TRUE)
  	    must_redraw = 0;
      }
      else
      {
  	/* Not VALID or INVERTED: redraw all lines. */
  	mid_start = 0;
  	mid_end = wp->w_height;
      }
  
      if (type == SOME_VALID)
      {
  	/* SOME_VALID: redraw all lines. */
  	mid_start = 0;
  	mid_end = wp->w_height;
  	type = NOT_VALID;
      }
  
      /* check if we are updating or removing the inverted part */
      if ((VIsual_active && buf == curwin->w_buffer)
  	    || (wp->w_old_cursor_lnum != 0 && type != NOT_VALID))
      {
  	linenr_T    from, to;
  
  	if (VIsual_active)
  	{
  	    if (VIsual_active
  		    && (VIsual_mode != wp->w_old_visual_mode
  			|| type == INVERTED_ALL))
  	    {
  		/*
  		 * If the type of Visual selection changed, redraw the whole
  		 * selection.  Also when the ownership of the X selection is
  		 * gained or lost.
  		 */
  		if (curwin->w_cursor.lnum < VIsual.lnum)
  		{
  		    from = curwin->w_cursor.lnum;
  		    to = VIsual.lnum;
  		}
  		else
  		{
  		    from = VIsual.lnum;
  		    to = curwin->w_cursor.lnum;
  		}
  		/* redraw more when the cursor moved as well */
  		if (wp->w_old_cursor_lnum < from)
  		    from = wp->w_old_cursor_lnum;
  		if (wp->w_old_cursor_lnum > to)
  		    to = wp->w_old_cursor_lnum;
  		if (wp->w_old_visual_lnum < from)
  		    from = wp->w_old_visual_lnum;
  		if (wp->w_old_visual_lnum > to)
  		    to = wp->w_old_visual_lnum;
  	    }
  	    else
  	    {
  		/*
  		 * Find the line numbers that need to be updated: The lines
  		 * between the old cursor position and the current cursor
  		 * position.  Also check if the Visual position changed.
  		 */
  		if (curwin->w_cursor.lnum < wp->w_old_cursor_lnum)
  		{
  		    from = curwin->w_cursor.lnum;
  		    to = wp->w_old_cursor_lnum;
  		}
  		else
  		{
  		    from = wp->w_old_cursor_lnum;
  		    to = curwin->w_cursor.lnum;
  		    if (from == 0)	/* Visual mode just started */
  			from = to;
  		}
  
  		if (VIsual.lnum != wp->w_old_visual_lnum
  					|| VIsual.col != wp->w_old_visual_col)
  		{
  		    if (wp->w_old_visual_lnum < from
  						&& wp->w_old_visual_lnum != 0)
  			from = wp->w_old_visual_lnum;
  		    if (wp->w_old_visual_lnum > to)
  			to = wp->w_old_visual_lnum;
  		    if (VIsual.lnum < from)
  			from = VIsual.lnum;
  		    if (VIsual.lnum > to)
  			to = VIsual.lnum;
  		}
  	    }
  
  	    /*
  	     * If in block mode and changed column or curwin->w_curswant:
  	     * update all lines.
  	     * First compute the actual start and end column.
  	     */
  	    if (VIsual_mode == Ctrl_V)
  	    {
  		colnr_T	    fromc, toc;
  #if defined(FEAT_VIRTUALEDIT) && defined(FEAT_LINEBREAK)
  		int	    save_ve_flags = ve_flags;
  
  		if (curwin->w_p_lbr)
  		    ve_flags = VE_ALL;
  #endif
  		getvcols(wp, &VIsual, &curwin->w_cursor, &fromc, &toc);
  #if defined(FEAT_VIRTUALEDIT) && defined(FEAT_LINEBREAK)
  		ve_flags = save_ve_flags;
  #endif
  		++toc;
  		if (curwin->w_curswant == MAXCOL)
  		    toc = MAXCOL;
  
  		if (fromc != wp->w_old_cursor_fcol
  			|| toc != wp->w_old_cursor_lcol)
  		{
  		    if (from > VIsual.lnum)
  			from = VIsual.lnum;
  		    if (to < VIsual.lnum)
  			to = VIsual.lnum;
  		}
  		wp->w_old_cursor_fcol = fromc;
  		wp->w_old_cursor_lcol = toc;
  	    }
  	}
  	else
  	{
  	    /* Use the line numbers of the old Visual area. */
  	    if (wp->w_old_cursor_lnum < wp->w_old_visual_lnum)
  	    {
  		from = wp->w_old_cursor_lnum;
  		to = wp->w_old_visual_lnum;
  	    }
  	    else
  	    {
  		from = wp->w_old_visual_lnum;
  		to = wp->w_old_cursor_lnum;
  	    }
  	}
  
  	/*
  	 * There is no need to update lines above the top of the window.
  	 */
  	if (from < wp->w_topline)
  	    from = wp->w_topline;
  
  	/*
  	 * If we know the value of w_botline, use it to restrict the update to
  	 * the lines that are visible in the window.
  	 */
  	if (wp->w_valid & VALID_BOTLINE)
  	{
  	    if (from >= wp->w_botline)
  		from = wp->w_botline - 1;
  	    if (to >= wp->w_botline)
  		to = wp->w_botline - 1;
  	}
  
  	/*
  	 * Find the minimal part to be updated.
  	 * Watch out for scrolling that made entries in w_lines[] invalid.
  	 * E.g., CTRL-U makes the first half of w_lines[] invalid and sets
  	 * top_end; need to redraw from top_end to the "to" line.
  	 * A middle mouse click with a Visual selection may change the text
  	 * above the Visual area and reset wl_valid, do count these for
  	 * mid_end (in srow).
  	 */
  	if (mid_start > 0)
  	{
  	    lnum = wp->w_topline;
  	    idx = 0;
  	    srow = 0;
  	    if (scrolled_down)
  		mid_start = top_end;
  	    else
  		mid_start = 0;
  	    while (lnum < from && idx < wp->w_lines_valid)	/* find start */
  	    {
  		if (wp->w_lines[idx].wl_valid)
  		    mid_start += wp->w_lines[idx].wl_size;
  		else if (!scrolled_down)
  		    srow += wp->w_lines[idx].wl_size;
  		++idx;
  # ifdef FEAT_FOLDING
  		if (idx < wp->w_lines_valid && wp->w_lines[idx].wl_valid)
  		    lnum = wp->w_lines[idx].wl_lnum;
  		else
  # endif
  		    ++lnum;
  	    }
  	    srow += mid_start;
  	    mid_end = wp->w_height;
  	    for ( ; idx < wp->w_lines_valid; ++idx)		/* find end */
  	    {
  		if (wp->w_lines[idx].wl_valid
  			&& wp->w_lines[idx].wl_lnum >= to + 1)
  		{
  		    /* Only update until first row of this line */
  		    mid_end = srow;
  		    break;
  		}
  		srow += wp->w_lines[idx].wl_size;
  	    }
  	}
      }
  
      if (VIsual_active && buf == curwin->w_buffer)
      {
  	wp->w_old_visual_mode = VIsual_mode;
  	wp->w_old_cursor_lnum = curwin->w_cursor.lnum;
  	wp->w_old_visual_lnum = VIsual.lnum;
  	wp->w_old_visual_col = VIsual.col;
  	wp->w_old_curswant = curwin->w_curswant;
      }
      else
      {
  	wp->w_old_visual_mode = 0;
  	wp->w_old_cursor_lnum = 0;
  	wp->w_old_visual_lnum = 0;
  	wp->w_old_visual_col = 0;
      }
  
  #if defined(FEAT_SYN_HL) || defined(FEAT_SEARCH_EXTRA)
      /* reset got_int, otherwise regexp won't work */
      save_got_int = got_int;
      got_int = 0;
  #endif
  #ifdef SYN_TIME_LIMIT
      /* Set the time limit to 'redrawtime'. */
      profile_setlimit(p_rdt, &syntax_tm);
      syn_set_timeout(&syntax_tm);
  #endif
  #ifdef FEAT_FOLDING
      win_foldinfo.fi_level = 0;
  #endif
  
  #ifdef FEAT_MENU
      /*
       * Draw the window toolbar, if there is one.
       * TODO: only when needed.
       */
      if (winbar_height(wp) > 0)
  	redraw_win_toolbar(wp);
  #endif
  
      /*
       * Update all the window rows.
       */
      idx = 0;		/* first entry in w_lines[].wl_size */
      row = 0;
      srow = 0;
      lnum = wp->w_topline;	/* first line shown in window */
      for (;;)
      {
  	/* stop updating when reached the end of the window (check for _past_
  	 * the end of the window is at the end of the loop) */
  	if (row == wp->w_height)
  	{
  	    didline = TRUE;
  	    break;
  	}
  
  	/* stop updating when hit the end of the file */
  	if (lnum > buf->b_ml.ml_line_count)
  	{
  	    eof = TRUE;
  	    break;
  	}
  
  	/* Remember the starting row of the line that is going to be dealt
  	 * with.  It is used further down when the line doesn't fit. */
  	srow = row;
  
  	/*
  	 * Update a line when it is in an area that needs updating, when it
  	 * has changes or w_lines[idx] is invalid.
  	 * bot_start may be halfway a wrapped line after using
  	 * win_del_lines(), check if the current line includes it.
  	 * When syntax folding is being used, the saved syntax states will
  	 * already have been updated, we can't see where the syntax state is
  	 * the same again, just update until the end of the window.
  	 */
  	if (row < top_end
  		|| (row >= mid_start && row < mid_end)
  #ifdef FEAT_SEARCH_EXTRA
  		|| top_to_mod
  #endif
  		|| idx >= wp->w_lines_valid
  		|| (row + wp->w_lines[idx].wl_size > bot_start)
  		|| (mod_top != 0
  		    && (lnum == mod_top
  			|| (lnum >= mod_top
  			    && (lnum < mod_bot
  #ifdef FEAT_SYN_HL
  				|| did_update == DID_FOLD
  				|| (did_update == DID_LINE
  				    && syntax_present(wp)
  				    && (
  # ifdef FEAT_FOLDING
  					(foldmethodIsSyntax(wp)
  						      && hasAnyFolding(wp)) ||
  # endif
  					syntax_check_changed(lnum)))
  #endif
  #ifdef FEAT_SEARCH_EXTRA
  				/* match in fixed position might need redraw
  				 * if lines were inserted or deleted */
  				|| (wp->w_match_head != NULL
  						    && buf->b_mod_xlines != 0)
  #endif
  				)))))
  	{
  #ifdef FEAT_SEARCH_EXTRA
  	    if (lnum == mod_top)
  		top_to_mod = FALSE;
  #endif
  
  	    /*
  	     * When at start of changed lines: May scroll following lines
  	     * up or down to minimize redrawing.
  	     * Don't do this when the change continues until the end.
  	     * Don't scroll when dollar_vcol >= 0, keep the "$".
  	     */
  	    if (lnum == mod_top
  		    && mod_bot != MAXLNUM
  		    && !(dollar_vcol >= 0 && mod_bot == mod_top + 1))
  	    {
  		int		old_rows = 0;
  		int		new_rows = 0;
  		int		xtra_rows;
  		linenr_T	l;
  
  		/* Count the old number of window rows, using w_lines[], which
  		 * should still contain the sizes for the lines as they are
  		 * currently displayed. */
  		for (i = idx; i < wp->w_lines_valid; ++i)
  		{
  		    /* Only valid lines have a meaningful wl_lnum.  Invalid
  		     * lines are part of the changed area. */
  		    if (wp->w_lines[i].wl_valid
  			    && wp->w_lines[i].wl_lnum == mod_bot)
  			break;
  		    old_rows += wp->w_lines[i].wl_size;
  #ifdef FEAT_FOLDING
  		    if (wp->w_lines[i].wl_valid
  			    && wp->w_lines[i].wl_lastlnum + 1 == mod_bot)
  		    {
  			/* Must have found the last valid entry above mod_bot.
  			 * Add following invalid entries. */
  			++i;
  			while (i < wp->w_lines_valid
  						  && !wp->w_lines[i].wl_valid)
  			    old_rows += wp->w_lines[i++].wl_size;
  			break;
  		    }
  #endif
  		}
  
  		if (i >= wp->w_lines_valid)
  		{
  		    /* We can't find a valid line below the changed lines,
  		     * need to redraw until the end of the window.
  		     * Inserting/deleting lines has no use. */
  		    bot_start = 0;
  		}
  		else
  		{
  		    /* Able to count old number of rows: Count new window
  		     * rows, and may insert/delete lines */
  		    j = idx;
  		    for (l = lnum; l < mod_bot; ++l)
  		    {
  #ifdef FEAT_FOLDING
  			if (hasFoldingWin(wp, l, NULL, &l, TRUE, NULL))
  			    ++new_rows;
  			else
  #endif
  #ifdef FEAT_DIFF
  			    if (l == wp->w_topline)
  			    new_rows += plines_win_nofill(wp, l, TRUE)
  							      + wp->w_topfill;
  			else
  #endif
  			    new_rows += plines_win(wp, l, TRUE);
  			++j;
  			if (new_rows > wp->w_height - row - 2)
  			{
  			    /* it's getting too much, must redraw the rest */
  			    new_rows = 9999;
  			    break;
  			}
  		    }
  		    xtra_rows = new_rows - old_rows;
  		    if (xtra_rows < 0)
  		    {
  			/* May scroll text up.  If there is not enough
  			 * remaining text or scrolling fails, must redraw the
  			 * rest.  If scrolling works, must redraw the text
  			 * below the scrolled text. */
  			if (row - xtra_rows >= wp->w_height - 2)
  			    mod_bot = MAXLNUM;
  			else
  			{
  			    check_for_delay(FALSE);
  			    if (win_del_lines(wp, row,
  					  -xtra_rows, FALSE, FALSE, 0) == FAIL)
  				mod_bot = MAXLNUM;
  			    else
  				bot_start = wp->w_height + xtra_rows;
  			}
  		    }
  		    else if (xtra_rows > 0)
  		    {
  			/* May scroll text down.  If there is not enough
  			 * remaining text of scrolling fails, must redraw the
  			 * rest. */
  			if (row + xtra_rows >= wp->w_height - 2)
  			    mod_bot = MAXLNUM;
  			else
  			{
  			    check_for_delay(FALSE);
  			    if (win_ins_lines(wp, row + old_rows,
  					     xtra_rows, FALSE, FALSE) == FAIL)
  				mod_bot = MAXLNUM;
  			    else if (top_end > row + old_rows)
  				/* Scrolled the part at the top that requires
  				 * updating down. */
  				top_end += xtra_rows;
  			}
  		    }
  
  		    /* When not updating the rest, may need to move w_lines[]
  		     * entries. */
  		    if (mod_bot != MAXLNUM && i != j)
  		    {
  			if (j < i)
  			{
  			    int x = row + new_rows;
  
  			    /* move entries in w_lines[] upwards */
  			    for (;;)
  			    {
  				/* stop at last valid entry in w_lines[] */
  				if (i >= wp->w_lines_valid)
  				{
  				    wp->w_lines_valid = j;
  				    break;
  				}
  				wp->w_lines[j] = wp->w_lines[i];
  				/* stop at a line that won't fit */
  				if (x + (int)wp->w_lines[j].wl_size
  							   > wp->w_height)
  				{
  				    wp->w_lines_valid = j + 1;
  				    break;
  				}
  				x += wp->w_lines[j++].wl_size;
  				++i;
  			    }
  			    if (bot_start > x)
  				bot_start = x;
  			}
  			else /* j > i */
  			{
  			    /* move entries in w_lines[] downwards */
  			    j -= i;
  			    wp->w_lines_valid += j;
  			    if (wp->w_lines_valid > wp->w_height)
  				wp->w_lines_valid = wp->w_height;
  			    for (i = wp->w_lines_valid; i - j >= idx; --i)
  				wp->w_lines[i] = wp->w_lines[i - j];
  
  			    /* The w_lines[] entries for inserted lines are
  			     * now invalid, but wl_size may be used above.
  			     * Reset to zero. */
  			    while (i >= idx)
  			    {
  				wp->w_lines[i].wl_size = 0;
  				wp->w_lines[i--].wl_valid = FALSE;
  			    }
  			}
  		    }
  		}
  	    }
  
  #ifdef FEAT_FOLDING
  	    /*
  	     * When lines are folded, display one line for all of them.
  	     * Otherwise, display normally (can be several display lines when
  	     * 'wrap' is on).
  	     */
  	    fold_count = foldedCount(wp, lnum, &win_foldinfo);
  	    if (fold_count != 0)
  	    {
  		fold_line(wp, fold_count, &win_foldinfo, lnum, row);
  		++row;
  		--fold_count;
  		wp->w_lines[idx].wl_folded = TRUE;
  		wp->w_lines[idx].wl_lastlnum = lnum + fold_count;
  # ifdef FEAT_SYN_HL
  		did_update = DID_FOLD;
  # endif
  	    }
  	    else
  #endif
  	    if (idx < wp->w_lines_valid
  		    && wp->w_lines[idx].wl_valid
  		    && wp->w_lines[idx].wl_lnum == lnum
  		    && lnum > wp->w_topline
  		    && !(dy_flags & (DY_LASTLINE | DY_TRUNCATE))
  		    && srow + wp->w_lines[idx].wl_size > wp->w_height
  #ifdef FEAT_DIFF
  		    && diff_check_fill(wp, lnum) == 0
  #endif
  		    )
  	    {
  		/* This line is not going to fit.  Don't draw anything here,
  		 * will draw "@  " lines below. */
  		row = wp->w_height + 1;
  	    }
  	    else
  	    {
  #ifdef FEAT_SEARCH_EXTRA
  		prepare_search_hl(wp, lnum);
  #endif
  #ifdef FEAT_SYN_HL
  		/* Let the syntax stuff know we skipped a few lines. */
  		if (syntax_last_parsed != 0 && syntax_last_parsed + 1 < lnum
  						       && syntax_present(wp))
  		    syntax_end_parsing(syntax_last_parsed + 1);
  #endif
  
  		/*
  		 * Display one line.
  		 */
  		row = win_line(wp, lnum, srow, wp->w_height, mod_top == 0);
  
  #ifdef FEAT_FOLDING
  		wp->w_lines[idx].wl_folded = FALSE;
  		wp->w_lines[idx].wl_lastlnum = lnum;
  #endif
  #ifdef FEAT_SYN_HL
  		did_update = DID_LINE;
  		syntax_last_parsed = lnum;
  #endif
  	    }
  
  	    wp->w_lines[idx].wl_lnum = lnum;
  	    wp->w_lines[idx].wl_valid = TRUE;
  
  	    /* Past end of the window or end of the screen. Note that after
  	     * resizing wp->w_height may be end up too big. That's a problem
  	     * elsewhere, but prevent a crash here. */
  	    if (row > wp->w_height || row + wp->w_winrow >= Rows)
  	    {
  		/* we may need the size of that too long line later on */
  		if (dollar_vcol == -1)
  		    wp->w_lines[idx].wl_size = plines_win(wp, lnum, TRUE);
  		++idx;
  		break;
  	    }
  	    if (dollar_vcol == -1)
  		wp->w_lines[idx].wl_size = row - srow;
  	    ++idx;
  #ifdef FEAT_FOLDING
  	    lnum += fold_count + 1;
  #else
  	    ++lnum;
  #endif
  	}
  	else
  	{
  	    /* This line does not need updating, advance to the next one */
  	    row += wp->w_lines[idx++].wl_size;
  	    if (row > wp->w_height)	/* past end of screen */
  		break;
  #ifdef FEAT_FOLDING
  	    lnum = wp->w_lines[idx - 1].wl_lastlnum + 1;
  #else
  	    ++lnum;
  #endif
  #ifdef FEAT_SYN_HL
  	    did_update = DID_NONE;
  #endif
  	}
  
  	if (lnum > buf->b_ml.ml_line_count)
  	{
  	    eof = TRUE;
  	    break;
  	}
      }
      /*
       * End of loop over all window lines.
       */
  
  #ifdef FEAT_VTP
      /* Rewrite the character at the end of the screen line. */
      if (use_vtp())
      {
  	int i;
  
  	for (i = 0; i < Rows; ++i)
  # ifdef FEAT_MBYTE
  	    if (enc_utf8)
  		if ((*mb_off2cells)(LineOffset[i] + Columns - 2,
  					   LineOffset[i] + screen_Columns) > 1)
  		    screen_draw_rectangle(i, Columns - 2, 1, 2, FALSE);
  		else
  		    screen_draw_rectangle(i, Columns - 1, 1, 1, FALSE);
  	    else
  # endif
  		screen_char(LineOffset[i] + Columns - 1, i, Columns - 1);
      }
  #endif
  
      if (idx > wp->w_lines_valid)
  	wp->w_lines_valid = idx;
  
  #ifdef FEAT_SYN_HL
      /*
       * Let the syntax stuff know we stop parsing here.
       */
      if (syntax_last_parsed != 0 && syntax_present(wp))
  	syntax_end_parsing(syntax_last_parsed + 1);
  #endif
  
      /*
       * If we didn't hit the end of the file, and we didn't finish the last
       * line we were working on, then the line didn't fit.
       */
      wp->w_empty_rows = 0;
  #ifdef FEAT_DIFF
      wp->w_filler_rows = 0;
  #endif
      if (!eof && !didline)
      {
  	if (lnum == wp->w_topline)
  	{
  	    /*
  	     * Single line that does not fit!
  	     * Don't overwrite it, it can be edited.
  	     */
  	    wp->w_botline = lnum + 1;
  	}
  #ifdef FEAT_DIFF
  	else if (diff_check_fill(wp, lnum) >= wp->w_height - srow)
  	{
  	    /* Window ends in filler lines. */
  	    wp->w_botline = lnum;
  	    wp->w_filler_rows = wp->w_height - srow;
  	}
  #endif
  	else if (dy_flags & DY_TRUNCATE)	/* 'display' has "truncate" */
  	{
  	    int scr_row = W_WINROW(wp) + wp->w_height - 1;
  
  	    /*
  	     * Last line isn't finished: Display "@@@" in the last screen line.
  	     */
  	    screen_puts_len((char_u *)"@@", 2, scr_row, wp->w_wincol,
  							      HL_ATTR(HLF_AT));
  	    screen_fill(scr_row, scr_row + 1,
  		    (int)wp->w_wincol + 2, (int)W_ENDCOL(wp),
  		    '@', ' ', HL_ATTR(HLF_AT));
  	    set_empty_rows(wp, srow);
  	    wp->w_botline = lnum;
  	}
  	else if (dy_flags & DY_LASTLINE)	/* 'display' has "lastline" */
  	{
  	    /*
  	     * Last line isn't finished: Display "@@@" at the end.
  	     */
  	    screen_fill(W_WINROW(wp) + wp->w_height - 1,
  		    W_WINROW(wp) + wp->w_height,
  		    (int)W_ENDCOL(wp) - 3, (int)W_ENDCOL(wp),
  		    '@', '@', HL_ATTR(HLF_AT));
  	    set_empty_rows(wp, srow);
  	    wp->w_botline = lnum;
  	}
  	else
  	{
  	    win_draw_end(wp, '@', ' ', srow, wp->w_height, HLF_AT);
  	    wp->w_botline = lnum;
  	}
      }
      else
      {
  	draw_vsep_win(wp, row);
  	if (eof)		/* we hit the end of the file */
  	{
  	    wp->w_botline = buf->b_ml.ml_line_count + 1;
  #ifdef FEAT_DIFF
  	    j = diff_check_fill(wp, wp->w_botline);
  	    if (j > 0 && !wp->w_botfill)
  	    {
  		/*
  		 * Display filler lines at the end of the file
  		 */
  		if (char2cells(fill_diff) > 1)
  		    i = '-';
  		else
  		    i = fill_diff;
  		if (row + j > wp->w_height)
  		    j = wp->w_height - row;
  		win_draw_end(wp, i, i, row, row + (int)j, HLF_DED);
  		row += j;
  	    }
  #endif
  	}
  	else if (dollar_vcol == -1)
  	    wp->w_botline = lnum;
  
  	/* make sure the rest of the screen is blank */
  	/* put '~'s on rows that aren't part of the file. */
  	win_draw_end(wp, '~', ' ', row, wp->w_height, HLF_EOB);
      }
  
  #ifdef SYN_TIME_LIMIT
      syn_set_timeout(NULL);
  #endif
  
      /* Reset the type of redrawing required, the window has been updated. */
      wp->w_redr_type = 0;
  #ifdef FEAT_DIFF
      wp->w_old_topfill = wp->w_topfill;
      wp->w_old_botfill = wp->w_botfill;
  #endif
  
      if (dollar_vcol == -1)
      {
  	/*
  	 * There is a trick with w_botline.  If we invalidate it on each
  	 * change that might modify it, this will cause a lot of expensive
  	 * calls to plines() in update_topline() each time.  Therefore the
  	 * value of w_botline is often approximated, and this value is used to
  	 * compute the value of w_topline.  If the value of w_botline was
  	 * wrong, check that the value of w_topline is correct (cursor is on
  	 * the visible part of the text).  If it's not, we need to redraw
  	 * again.  Mostly this just means scrolling up a few lines, so it
  	 * doesn't look too bad.  Only do this for the current window (where
  	 * changes are relevant).
  	 */
  	wp->w_valid |= VALID_BOTLINE;
  	if (wp == curwin && wp->w_botline != old_botline && !recursive)
  	{
  	    recursive = TRUE;
  	    curwin->w_valid &= ~VALID_TOPLINE;
  	    update_topline();	/* may invalidate w_botline again */
  	    if (must_redraw != 0)
  	    {
  		/* Don't update for changes in buffer again. */
  		i = curbuf->b_mod_set;
  		curbuf->b_mod_set = FALSE;
  		win_update(curwin);
  		must_redraw = 0;
  		curbuf->b_mod_set = i;
  	    }
  	    recursive = FALSE;
  	}
      }
  
  #if defined(FEAT_SYN_HL) || defined(FEAT_SEARCH_EXTRA)
      /* restore got_int, unless CTRL-C was hit while redrawing */
      if (!got_int)
  	got_int = save_got_int;
  #endif
  }
  
  /*
   * Clear the rest of the window and mark the unused lines with "c1".  use "c2"
   * as the filler character.
   */
      static void
  win_draw_end(
      win_T	*wp,
      int		c1,
      int		c2,
      int		row,
      int		endrow,
      hlf_T	hl)
  {
  #if defined(FEAT_FOLDING) || defined(FEAT_SIGNS) || defined(FEAT_CMDWIN)
      int		n = 0;
  # define FDC_OFF n
  #else
  # define FDC_OFF 0
  #endif
  #ifdef FEAT_FOLDING
      int		fdc = compute_foldcolumn(wp, 0);
  #endif
  
  #ifdef FEAT_RIGHTLEFT
      if (wp->w_p_rl)
      {
  	/* No check for cmdline window: should never be right-left. */
  # ifdef FEAT_FOLDING
  	n = fdc;
  
  	if (n > 0)
  	{
  	    /* draw the fold column at the right */
  	    if (n > wp->w_width)
  		n = wp->w_width;
  	    screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow,
  		    W_ENDCOL(wp) - n, (int)W_ENDCOL(wp),
  		    ' ', ' ', HL_ATTR(HLF_FC));
  	}
  # endif
  # ifdef FEAT_SIGNS
  	if (signcolumn_on(wp))
  	{
  	    int nn = n + 2;
  
  	    /* draw the sign column left of the fold column */
  	    if (nn > wp->w_width)
  		nn = wp->w_width;
  	    screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow,
  		    W_ENDCOL(wp) - nn, (int)W_ENDCOL(wp) - n,
  		    ' ', ' ', HL_ATTR(HLF_SC));
  	    n = nn;
  	}
  # endif
  	screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow,
  		wp->w_wincol, W_ENDCOL(wp) - 1 - FDC_OFF,
  		c2, c2, HL_ATTR(hl));
  	screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow,
  		W_ENDCOL(wp) - 1 - FDC_OFF, W_ENDCOL(wp) - FDC_OFF,
  		c1, c2, HL_ATTR(hl));
      }
      else
  #endif
      {
  #ifdef FEAT_CMDWIN
  	if (cmdwin_type != 0 && wp == curwin)
  	{
  	    /* draw the cmdline character in the leftmost column */
  	    n = 1;
  	    if (n > wp->w_width)
  		n = wp->w_width;
  	    screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow,
  		    wp->w_wincol, (int)wp->w_wincol + n,
  		    cmdwin_type, ' ', HL_ATTR(HLF_AT));
  	}
  #endif
  #ifdef FEAT_FOLDING
  	if (fdc > 0)
  	{
  	    int	    nn = n + fdc;
  
  	    /* draw the fold column at the left */
  	    if (nn > wp->w_width)
  		nn = wp->w_width;
  	    screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow,
  		    wp->w_wincol + n, (int)wp->w_wincol + nn,
  		    ' ', ' ', HL_ATTR(HLF_FC));
  	    n = nn;
  	}
  #endif
  #ifdef FEAT_SIGNS
  	if (signcolumn_on(wp))
  	{
  	    int	    nn = n + 2;
  
  	    /* draw the sign column after the fold column */
  	    if (nn > wp->w_width)
  		nn = wp->w_width;
  	    screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow,
  		    wp->w_wincol + n, (int)wp->w_wincol + nn,
  		    ' ', ' ', HL_ATTR(HLF_SC));
  	    n = nn;
  	}
  #endif
  	screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow,
  		wp->w_wincol + FDC_OFF, (int)W_ENDCOL(wp),
  		c1, c2, HL_ATTR(hl));
      }
      set_empty_rows(wp, row);
  }
  
  #ifdef FEAT_SYN_HL
  static int advance_color_col(int vcol, int **color_cols);
  
  /*
   * Advance **color_cols and return TRUE when there are columns to draw.
   */
      static int
  advance_color_col(int vcol, int **color_cols)
  {
      while (**color_cols >= 0 && vcol > **color_cols)
  	++*color_cols;
      return (**color_cols >= 0);
  }
  #endif
  
  #if defined(FEAT_MENU) || defined(FEAT_FOLDING)
  /*
   * Copy "text" to ScreenLines using "attr".
   * Returns the next screen column.
   */
      static int
  text_to_screenline(win_T *wp, char_u *text, int col)
  {
      int		off = (int)(current_ScreenLine - ScreenLines);
  
  #ifdef FEAT_MBYTE
      if (has_mbyte)
      {
  	int	cells;
  	int	u8c, u8cc[MAX_MCO];
  	int	i;
  	int	idx;
  	int	c_len;
  	char_u	*p;
  # ifdef FEAT_ARABIC
  	int	prev_c = 0;		/* previous Arabic character */
  	int	prev_c1 = 0;		/* first composing char for prev_c */
  # endif
  
  # ifdef FEAT_RIGHTLEFT
  	if (wp->w_p_rl)
  	    idx = off;
  	else
  # endif
  	    idx = off + col;
  
  	/* Store multibyte characters in ScreenLines[] et al. correctly. */
  	for (p = text; *p != NUL; )
  	{
  	    cells = (*mb_ptr2cells)(p);
  	    c_len = (*mb_ptr2len)(p);
  	    if (col + cells > wp->w_width
  # ifdef FEAT_RIGHTLEFT
  		    - (wp->w_p_rl ? col : 0)
  # endif
  		    )
  		break;
  	    ScreenLines[idx] = *p;
  	    if (enc_utf8)
  	    {
  		u8c = utfc_ptr2char(p, u8cc);
  		if (*p < 0x80 && u8cc[0] == 0)
  		{
  		    ScreenLinesUC[idx] = 0;
  #ifdef FEAT_ARABIC
  		    prev_c = u8c;
  #endif
  		}
  		else
  		{
  #ifdef FEAT_ARABIC
  		    if (p_arshape && !p_tbidi && ARABIC_CHAR(u8c))
  		    {
  			/* Do Arabic shaping. */
  			int	pc, pc1, nc;
  			int	pcc[MAX_MCO];
  			int	firstbyte = *p;
  
  			/* The idea of what is the previous and next
  			 * character depends on 'rightleft'. */
  			if (wp->w_p_rl)
  			{
  			    pc = prev_c;
  			    pc1 = prev_c1;
  			    nc = utf_ptr2char(p + c_len);
  			    prev_c1 = u8cc[0];
  			}
  			else
  			{
  			    pc = utfc_ptr2char(p + c_len, pcc);
  			    nc = prev_c;
  			    pc1 = pcc[0];
  			}
  			prev_c = u8c;
  
  			u8c = arabic_shape(u8c, &firstbyte, &u8cc[0],
  								 pc, pc1, nc);
  			ScreenLines[idx] = firstbyte;
  		    }
  		    else
  			prev_c = u8c;
  #endif
  		    /* Non-BMP character: display as ? or fullwidth ?. */
  #ifdef UNICODE16
  		    if (u8c >= 0x10000)
  			ScreenLinesUC[idx] = (cells == 2) ? 0xff1f : (int)'?';
  		    else
  #endif
  			ScreenLinesUC[idx] = u8c;
  		    for (i = 0; i < Screen_mco; ++i)
  		    {
  			ScreenLinesC[i][idx] = u8cc[i];
  			if (u8cc[i] == 0)
  			    break;
  		    }
  		}
  		if (cells > 1)
  		    ScreenLines[idx + 1] = 0;
  	    }
  	    else if (enc_dbcs == DBCS_JPNU && *p == 0x8e)
  		/* double-byte single width character */
  		ScreenLines2[idx] = p[1];
  	    else if (cells > 1)
  		/* double-width character */
  		ScreenLines[idx + 1] = p[1];
  	    col += cells;
  	    idx += cells;
  	    p += c_len;
  	}
      }
      else
  #endif
      {
  	int len = (int)STRLEN(text);
  
  	if (len > wp->w_width - col)
  	    len = wp->w_width - col;
  	if (len > 0)
  	{
  #ifdef FEAT_RIGHTLEFT
  	    if (wp->w_p_rl)
  		STRNCPY(current_ScreenLine, text, len);
  	    else
  #endif
  		STRNCPY(current_ScreenLine + col, text, len);
  	    col += len;
  	}
      }
      return col;
  }
  #endif
  
  #ifdef FEAT_FOLDING
  /*
   * Compute the width of the foldcolumn.  Based on 'foldcolumn' and how much
   * space is available for window "wp", minus "col".
   */
      static int
  compute_foldcolumn(win_T *wp, int col)
  {
      int fdc = wp->w_p_fdc;
      int wmw = wp == curwin && p_wmw == 0 ? 1 : p_wmw;
      int wwidth = wp->w_width;
  
      if (fdc > wwidth - (col + wmw))
  	fdc = wwidth - (col + wmw);
      return fdc;
  }
  
  /*
   * Display one folded line.
   */
      static void
  fold_line(
      win_T	*wp,
      long	fold_count,
      foldinfo_T	*foldinfo,
      linenr_T	lnum,
      int		row)
  {
      char_u	buf[FOLD_TEXT_LEN];
      pos_T	*top, *bot;
      linenr_T	lnume = lnum + fold_count - 1;
      int		len;
      char_u	*text;
      int		fdc;
      int		col;
      int		txtcol;
      int		off = (int)(current_ScreenLine - ScreenLines);
      int		ri;
  
      /* Build the fold line:
       * 1. Add the cmdwin_type for the command-line window
       * 2. Add the 'foldcolumn'
       * 3. Add the 'number' or 'relativenumber' column
       * 4. Compose the text
       * 5. Add the text
       * 6. set highlighting for the Visual area an other text
       */
      col = 0;
  
      /*
       * 1. Add the cmdwin_type for the command-line window
       * Ignores 'rightleft', this window is never right-left.
       */
  #ifdef FEAT_CMDWIN
      if (cmdwin_type != 0 && wp == curwin)
      {
  	ScreenLines[off] = cmdwin_type;
  	ScreenAttrs[off] = HL_ATTR(HLF_AT);
  #ifdef FEAT_MBYTE
  	if (enc_utf8)
  	    ScreenLinesUC[off] = 0;
  #endif
  	++col;
      }
  #endif
  
      /*
       * 2. Add the 'foldcolumn'
       *    Reduce the width when there is not enough space.
       */
      fdc = compute_foldcolumn(wp, col);
      if (fdc > 0)
      {
  	fill_foldcolumn(buf, wp, TRUE, lnum);
  #ifdef FEAT_RIGHTLEFT
  	if (wp->w_p_rl)
  	{
  	    int		i;
  
  	    copy_text_attr(off + wp->w_width - fdc - col, buf, fdc,
  							     HL_ATTR(HLF_FC));
  	    /* reverse the fold column */
  	    for (i = 0; i < fdc; ++i)
  		ScreenLines[off + wp->w_width - i - 1 - col] = buf[i];
  	}
  	else
  #endif
  	    copy_text_attr(off + col, buf, fdc, HL_ATTR(HLF_FC));
  	col += fdc;
      }
  
  #ifdef FEAT_RIGHTLEFT
  # define RL_MEMSET(p, v, l) \
      do { \
  	if (wp->w_p_rl) \
  	    for (ri = 0; ri < l; ++ri) \
  	       ScreenAttrs[off + (wp->w_width - (p) - (l)) + ri] = v; \
  	 else \
  	    for (ri = 0; ri < l; ++ri) \
  	       ScreenAttrs[off + (p) + ri] = v; \
      } while (0)
  #else
  # define RL_MEMSET(p, v, l) \
      do { \
  	for (ri = 0; ri < l; ++ri) \
  	    ScreenAttrs[off + (p) + ri] = v; \
      } while (0)
  #endif
  
      /* Set all attributes of the 'number' or 'relativenumber' column and the
       * text */
      RL_MEMSET(col, HL_ATTR(HLF_FL), wp->w_width - col);
  
  #ifdef FEAT_SIGNS
      /* If signs are being displayed, add two spaces. */
      if (signcolumn_on(wp))
      {
  	len = wp->w_width - col;
  	if (len > 0)
  	{
  	    if (len > 2)
  		len = 2;
  # ifdef FEAT_RIGHTLEFT
  	    if (wp->w_p_rl)
  		/* the line number isn't reversed */
  		copy_text_attr(off + wp->w_width - len - col,
  					(char_u *)"  ", len, HL_ATTR(HLF_FL));
  	    else
  # endif
  		copy_text_attr(off + col, (char_u *)"  ", len, HL_ATTR(HLF_FL));
  	    col += len;
  	}
      }
  #endif
  
      /*
       * 3. Add the 'number' or 'relativenumber' column
       */
      if (wp->w_p_nu || wp->w_p_rnu)
      {
  	len = wp->w_width - col;
  	if (len > 0)
  	{
  	    int	    w = number_width(wp);
  	    long    num;
  	    char    *fmt = "%*ld ";
  
  	    if (len > w + 1)
  		len = w + 1;
  
  	    if (wp->w_p_nu && !wp->w_p_rnu)
  		/* 'number' + 'norelativenumber' */
  		num = (long)lnum;
  	    else
  	    {
  		/* 'relativenumber', don't use negative numbers */
  		num = labs((long)get_cursor_rel_lnum(wp, lnum));
  		if (num == 0 && wp->w_p_nu && wp->w_p_rnu)
  		{
  		    /* 'number' + 'relativenumber': cursor line shows absolute
  		     * line number */
  		    num = lnum;
  		    fmt = "%-*ld ";
  		}
  	    }
  
  	    sprintf((char *)buf, fmt, w, num);
  #ifdef FEAT_RIGHTLEFT
  	    if (wp->w_p_rl)
  		/* the line number isn't reversed */
  		copy_text_attr(off + wp->w_width - len - col, buf, len,
  							     HL_ATTR(HLF_FL));
  	    else
  #endif
  		copy_text_attr(off + col, buf, len, HL_ATTR(HLF_FL));
  	    col += len;
  	}
      }
  
      /*
       * 4. Compose the folded-line string with 'foldtext', if set.
       */
      text = get_foldtext(wp, lnum, lnume, foldinfo, buf);
  
      txtcol = col;	/* remember where text starts */
  
      /*
       * 5. move the text to current_ScreenLine.  Fill up with "fill_fold".
       *    Right-left text is put in columns 0 - number-col, normal text is put
       *    in columns number-col - window-width.
       */
      col = text_to_screenline(wp, text, col);
  
      /* Fill the rest of the line with the fold filler */
  #ifdef FEAT_RIGHTLEFT
      if (wp->w_p_rl)
  	col -= txtcol;
  #endif
      while (col < wp->w_width
  #ifdef FEAT_RIGHTLEFT
  		    - (wp->w_p_rl ? txtcol : 0)
  #endif
  	    )
      {
  #ifdef FEAT_MBYTE
  	if (enc_utf8)
  	{
  	    if (fill_fold >= 0x80)
  	    {
  		ScreenLinesUC[off + col] = fill_fold;
  		ScreenLinesC[0][off + col] = 0;
  		ScreenLines[off + col] = 0x80; /* avoid storing zero */
  	    }
  	    else
  	    {
  		ScreenLinesUC[off + col] = 0;
  		ScreenLines[off + col] = fill_fold;
  	    }
  	    col++;
  	}
  	else
  #endif
  	    ScreenLines[off + col++] = fill_fold;
      }
  
      if (text != buf)
  	vim_free(text);
  
      /*
       * 6. set highlighting for the Visual area an other text.
       * If all folded lines are in the Visual area, highlight the line.
       */
      if (VIsual_active && wp->w_buffer == curwin->w_buffer)
      {
  	if (LTOREQ_POS(curwin->w_cursor, VIsual))
  	{
  	    /* Visual is after curwin->w_cursor */
  	    top = &curwin->w_cursor;
  	    bot = &VIsual;
  	}
  	else
  	{
  	    /* Visual is before curwin->w_cursor */
  	    top = &VIsual;
  	    bot = &curwin->w_cursor;
  	}
  	if (lnum >= top->lnum
  		&& lnume <= bot->lnum
  		&& (VIsual_mode != 'v'
  		    || ((lnum > top->lnum
  			    || (lnum == top->lnum
  				&& top->col == 0))
  			&& (lnume < bot->lnum
  			    || (lnume == bot->lnum
  				&& (bot->col - (*p_sel == 'e'))
  		>= (colnr_T)STRLEN(ml_get_buf(wp->w_buffer, lnume, FALSE)))))))
  	{
  	    if (VIsual_mode == Ctrl_V)
  	    {
  		/* Visual block mode: highlight the chars part of the block */
  		if (wp->w_old_cursor_fcol + txtcol < (colnr_T)wp->w_width)
  		{
  		    if (wp->w_old_cursor_lcol != MAXCOL
  			     && wp->w_old_cursor_lcol + txtcol
  						       < (colnr_T)wp->w_width)
  			len = wp->w_old_cursor_lcol;
  		    else
  			len = wp->w_width - txtcol;
  		    RL_MEMSET(wp->w_old_cursor_fcol + txtcol, HL_ATTR(HLF_V),
  					    len - (int)wp->w_old_cursor_fcol);
  		}
  	    }
  	    else
  	    {
  		/* Set all attributes of the text */
  		RL_MEMSET(txtcol, HL_ATTR(HLF_V), wp->w_width - txtcol);
  	    }
  	}
      }
  
  #ifdef FEAT_SYN_HL
      /* Show colorcolumn in the fold line, but let cursorcolumn override it. */
      if (wp->w_p_cc_cols)
      {
  	int i = 0;
  	int j = wp->w_p_cc_cols[i];
  	int old_txtcol = txtcol;
  
  	while (j > -1)
  	{
  	    txtcol += j;
  	    if (wp->w_p_wrap)
  		txtcol -= wp->w_skipcol;
  	    else
  		txtcol -= wp->w_leftcol;
  	    if (txtcol >= 0 && txtcol < wp->w_width)
  		ScreenAttrs[off + txtcol] = hl_combine_attr(
  				    ScreenAttrs[off + txtcol], HL_ATTR(HLF_MC));
  	    txtcol = old_txtcol;
  	    j = wp->w_p_cc_cols[++i];
  	}
      }
  
      /* Show 'cursorcolumn' in the fold line. */
      if (wp->w_p_cuc)
      {
  	txtcol += wp->w_virtcol;
  	if (wp->w_p_wrap)
  	    txtcol -= wp->w_skipcol;
  	else
  	    txtcol -= wp->w_leftcol;
  	if (txtcol >= 0 && txtcol < wp->w_width)
  	    ScreenAttrs[off + txtcol] = hl_combine_attr(
  				 ScreenAttrs[off + txtcol], HL_ATTR(HLF_CUC));
      }
  #endif
  
      screen_line(row + W_WINROW(wp), wp->w_wincol, (int)wp->w_width,
  						     (int)wp->w_width, FALSE);
  
      /*
       * Update w_cline_height and w_cline_folded if the cursor line was
       * updated (saves a call to plines() later).
       */
      if (wp == curwin
  	    && lnum <= curwin->w_cursor.lnum
  	    && lnume >= curwin->w_cursor.lnum)
      {
  	curwin->w_cline_row = row;
  	curwin->w_cline_height = 1;
  	curwin->w_cline_folded = TRUE;
  	curwin->w_valid |= (VALID_CHEIGHT|VALID_CROW);
      }
  }
  
  /*
   * Copy "buf[len]" to ScreenLines["off"] and set attributes to "attr".
   */
      static void
  copy_text_attr(
      int		off,
      char_u	*buf,
      int		len,
      int		attr)
  {
      int		i;
  
      mch_memmove(ScreenLines + off, buf, (size_t)len);
  # ifdef FEAT_MBYTE
      if (enc_utf8)
  	vim_memset(ScreenLinesUC + off, 0, sizeof(u8char_T) * (size_t)len);
  # endif
      for (i = 0; i < len; ++i)
  	ScreenAttrs[off + i] = attr;
  }
  
  /*
   * Fill the foldcolumn at "p" for window "wp".
   * Only to be called when 'foldcolumn' > 0.
   */
      static void
  fill_foldcolumn(
      char_u	*p,
      win_T	*wp,
      int		closed,		/* TRUE of FALSE */
      linenr_T	lnum)		/* current line number */
  {
      int		i = 0;
      int		level;
      int		first_level;
      int		empty;
      int		fdc = compute_foldcolumn(wp, 0);
  
      /* Init to all spaces. */
      vim_memset(p, ' ', (size_t)fdc);
  
      level = win_foldinfo.fi_level;
      if (level > 0)
      {
  	/* If there is only one column put more info in it. */
  	empty = (fdc == 1) ? 0 : 1;
  
  	/* If the column is too narrow, we start at the lowest level that
  	 * fits and use numbers to indicated the depth. */
  	first_level = level - fdc - closed + 1 + empty;
  	if (first_level < 1)
  	    first_level = 1;
  
  	for (i = 0; i + empty < fdc; ++i)
  	{
  	    if (win_foldinfo.fi_lnum == lnum
  			      && first_level + i >= win_foldinfo.fi_low_level)
  		p[i] = '-';
  	    else if (first_level == 1)
  		p[i] = '|';
  	    else if (first_level + i <= 9)
  		p[i] = '0' + first_level + i;
  	    else
  		p[i] = '>';
  	    if (first_level + i == level)
  		break;
  	}
      }
      if (closed)
  	p[i >= fdc ? i - 1 : i] = '+';
  }
  #endif /* FEAT_FOLDING */
  
  /*
   * Display line "lnum" of window 'wp' on the screen.
   * Start at row "startrow", stop when "endrow" is reached.
   * wp->w_virtcol needs to be valid.
   *
   * Return the number of last row the line occupies.
   */
      static int
  win_line(
      win_T	*wp,
      linenr_T	lnum,
      int		startrow,
      int		endrow,
      int		nochange UNUSED)	/* not updating for changed text */
  {
      int		col = 0;		/* visual column on screen */
      unsigned	off;			/* offset in ScreenLines/ScreenAttrs */
      int		c = 0;			/* init for GCC */
      long	vcol = 0;		/* virtual column (for tabs) */
  #ifdef FEAT_LINEBREAK
      long	vcol_sbr = -1;		/* virtual column after showbreak */
  #endif
      long	vcol_prev = -1;		/* "vcol" of previous character */
      char_u	*line;			/* current line */
      char_u	*ptr;			/* current position in "line" */
      int		row;			/* row in the window, excl w_winrow */
      int		screen_row;		/* row on the screen, incl w_winrow */
  
      char_u	extra[18];		/* "%ld" and 'fdc' must fit in here */
      int		n_extra = 0;		/* number of extra chars */
      char_u	*p_extra = NULL;	/* string of extra chars, plus NUL */
      char_u	*p_extra_free = NULL;   /* p_extra needs to be freed */
      int		c_extra = NUL;		/* extra chars, all the same */
      int		extra_attr = 0;		/* attributes when n_extra != 0 */
      static char_u *at_end_str = (char_u *)""; /* used for p_extra when
  					   displaying lcs_eol at end-of-line */
      int		lcs_eol_one = lcs_eol;	/* lcs_eol until it's been used */
      int		lcs_prec_todo = lcs_prec;   /* lcs_prec until it's been used */
  
      /* saved "extra" items for when draw_state becomes WL_LINE (again) */
      int		saved_n_extra = 0;
      char_u	*saved_p_extra = NULL;
      int		saved_c_extra = 0;
      int		saved_char_attr = 0;
  
      int		n_attr = 0;		/* chars with special attr */
      int		saved_attr2 = 0;	/* char_attr saved for n_attr */
      int		n_attr3 = 0;		/* chars with overruling special attr */
      int		saved_attr3 = 0;	/* char_attr saved for n_attr3 */
  
      int		n_skip = 0;		/* nr of chars to skip for 'nowrap' */
  
      int		fromcol, tocol;		/* start/end of inverting */
      int		fromcol_prev = -2;	/* start of inverting after cursor */
      int		noinvcur = FALSE;	/* don't invert the cursor */
      pos_T	*top, *bot;
      int		lnum_in_visual_area = FALSE;
      pos_T	pos;
      long	v;
  
      int		char_attr = 0;		/* attributes for next character */
      int		attr_pri = FALSE;	/* char_attr has priority */
      int		area_highlighting = FALSE; /* Visual or incsearch highlighting
  					      in this line */
      int		attr = 0;		/* attributes for area highlighting */
      int		area_attr = 0;		/* attributes desired by highlighting */
      int		search_attr = 0;	/* attributes desired by 'hlsearch' */
  #ifdef FEAT_SYN_HL
      int		vcol_save_attr = 0;	/* saved attr for 'cursorcolumn' */
      int		syntax_attr = 0;	/* attributes desired by syntax */
      int		has_syntax = FALSE;	/* this buffer has syntax highl. */
      int		save_did_emsg;
      int		eol_hl_off = 0;		/* 1 if highlighted char after EOL */
      int		draw_color_col = FALSE;	/* highlight colorcolumn */
      int		*color_cols = NULL;	/* pointer to according columns array */
  #endif
  #ifdef FEAT_SPELL
      int		has_spell = FALSE;	/* this buffer has spell checking */
  # define SPWORDLEN 150
      char_u	nextline[SPWORDLEN * 2];/* text with start of the next line */
      int		nextlinecol = 0;	/* column where nextline[] starts */
      int		nextline_idx = 0;	/* index in nextline[] where next line
  					   starts */
      int		spell_attr = 0;		/* attributes desired by spelling */
      int		word_end = 0;		/* last byte with same spell_attr */
      static linenr_T  checked_lnum = 0;	/* line number for "checked_col" */
      static int	checked_col = 0;	/* column in "checked_lnum" up to which
  					 * there are no spell errors */
      static int	cap_col = -1;		/* column to check for Cap word */
      static linenr_T capcol_lnum = 0;	/* line number where "cap_col" used */
      int		cur_checked_col = 0;	/* checked column for current line */
  #endif
      int		extra_check;		/* has syntax or linebreak */
  #ifdef FEAT_MBYTE
      int		multi_attr = 0;		/* attributes desired by multibyte */
      int		mb_l = 1;		/* multi-byte byte length */
      int		mb_c = 0;		/* decoded multi-byte character */
      int		mb_utf8 = FALSE;	/* screen char is UTF-8 char */
      int		u8cc[MAX_MCO];		/* composing UTF-8 chars */
  #endif
  #ifdef FEAT_DIFF
      int		filler_lines;		/* nr of filler lines to be drawn */
      int		filler_todo;		/* nr of filler lines still to do + 1 */
      hlf_T	diff_hlf = (hlf_T)0;	/* type of diff highlighting */
      int		change_start = MAXCOL;	/* first col of changed area */
      int		change_end = -1;	/* last col of changed area */
  #endif
      colnr_T	trailcol = MAXCOL;	/* start of trailing spaces */
  #ifdef FEAT_LINEBREAK
      int		need_showbreak = FALSE; /* overlong line, skipping first x
  					   chars */
  #endif
  #if defined(FEAT_SIGNS) || defined(FEAT_QUICKFIX) \
  	|| defined(FEAT_SYN_HL) || defined(FEAT_DIFF)
  # define LINE_ATTR
      int		line_attr = 0;		/* attribute for the whole line */
  #endif
  #ifdef FEAT_SEARCH_EXTRA
      matchitem_T *cur;			/* points to the match list */
      match_T	*shl;			/* points to search_hl or a match */
      int		shl_flag;		/* flag to indicate whether search_hl
  					   has been processed or not */
      int		pos_inprogress;		/* marks that position match search is
  					   in progress */
      int		prevcol_hl_flag;	/* flag to indicate whether prevcol
  					   equals startcol of search_hl or one
  					   of the matches */
  #endif
  #ifdef FEAT_ARABIC
      int		prev_c = 0;		/* previous Arabic character */
      int		prev_c1 = 0;		/* first composing char for prev_c */
  #endif
  #if defined(LINE_ATTR)
      int		did_line_attr = 0;
  #endif
  #ifdef FEAT_TERMINAL
      int		get_term_attr = FALSE;
      int		term_attr = 0;		/* background for terminal window */
  #endif
  
      /* draw_state: items that are drawn in sequence: */
  #define WL_START	0		/* nothing done yet */
  #ifdef FEAT_CMDWIN
  # define WL_CMDLINE	WL_START + 1	/* cmdline window column */
  #else
  # define WL_CMDLINE	WL_START
  #endif
  #ifdef FEAT_FOLDING
  # define WL_FOLD	WL_CMDLINE + 1	/* 'foldcolumn' */
  #else
  # define WL_FOLD	WL_CMDLINE
  #endif
  #ifdef FEAT_SIGNS
  # define WL_SIGN	WL_FOLD + 1	/* column for signs */
  #else
  # define WL_SIGN	WL_FOLD		/* column for signs */
  #endif
  #define WL_NR		WL_SIGN + 1	/* line number */
  #ifdef FEAT_LINEBREAK
  # define WL_BRI		WL_NR + 1	/* 'breakindent' */
  #else
  # define WL_BRI		WL_NR
  #endif
  #if defined(FEAT_LINEBREAK) || defined(FEAT_DIFF)
  # define WL_SBR		WL_BRI + 1	/* 'showbreak' or 'diff' */
  #else
  # define WL_SBR		WL_BRI
  #endif
  #define WL_LINE		WL_SBR + 1	/* text in the line */
      int		draw_state = WL_START;	/* what to draw next */
  #if defined(FEAT_XIM) && defined(FEAT_GUI_GTK)
      int		feedback_col = 0;
      int		feedback_old_attr = -1;
  #endif
  
  #ifdef FEAT_CONCEAL
      int		syntax_flags	= 0;
      int		syntax_seqnr	= 0;
      int		prev_syntax_id	= 0;
      int		conceal_attr	= HL_ATTR(HLF_CONCEAL);
      int		is_concealing	= FALSE;
      int		boguscols	= 0;	/* nonexistent columns added to force
  					   wrapping */
      int		vcol_off	= 0;	/* offset for concealed characters */
      int		did_wcol	= FALSE;
      int		match_conc	= 0;	/* cchar for match functions */
      int		has_match_conc  = 0;	/* match wants to conceal */
      int		old_boguscols   = 0;
  # define VCOL_HLC (vcol - vcol_off)
  # define FIX_FOR_BOGUSCOLS \
      { \
  	n_extra += vcol_off; \
  	vcol -= vcol_off; \
  	vcol_off = 0; \
  	col -= boguscols; \
  	old_boguscols = boguscols; \
  	boguscols = 0; \
      }
  #else
  # define VCOL_HLC (vcol)
  #endif
  
      if (startrow > endrow)		/* past the end already! */
  	return startrow;
  
      row = startrow;
      screen_row = row + W_WINROW(wp);
  
      /*
       * To speed up the loop below, set extra_check when there is linebreak,
       * trailing white space and/or syntax processing to be done.
       */
  #ifdef FEAT_LINEBREAK
      extra_check = wp->w_p_lbr;
  #else
      extra_check = 0;
  #endif
  #ifdef FEAT_SYN_HL
      if (syntax_present(wp) && !wp->w_s->b_syn_error
  # ifdef SYN_TIME_LIMIT
  	    && !wp->w_s->b_syn_slow
  # endif
         )
      {
  	/* Prepare for syntax highlighting in this line.  When there is an
  	 * error, stop syntax highlighting. */
  	save_did_emsg = did_emsg;
  	did_emsg = FALSE;
  	syntax_start(wp, lnum);
  	if (did_emsg)
  	    wp->w_s->b_syn_error = TRUE;
  	else
  	{
  	    did_emsg = save_did_emsg;
  #ifdef SYN_TIME_LIMIT
  	    if (!wp->w_s->b_syn_slow)
  #endif
  	    {
  		has_syntax = TRUE;
  		extra_check = TRUE;
  	    }
  	}
      }
  
      /* Check for columns to display for 'colorcolumn'. */
      color_cols = wp->w_p_cc_cols;
      if (color_cols != NULL)
  	draw_color_col = advance_color_col(VCOL_HLC, &color_cols);
  #endif
  
  #ifdef FEAT_TERMINAL
      if (term_show_buffer(wp->w_buffer))
      {
  	extra_check = TRUE;
  	get_term_attr = TRUE;
  	term_attr = term_get_attr(wp->w_buffer, lnum, -1);
      }
  #endif
  
  #ifdef FEAT_SPELL
      if (wp->w_p_spell
  	    && *wp->w_s->b_p_spl != NUL
  	    && wp->w_s->b_langp.ga_len > 0
  	    && *(char **)(wp->w_s->b_langp.ga_data) != NULL)
      {
  	/* Prepare for spell checking. */
  	has_spell = TRUE;
  	extra_check = TRUE;
  
  	/* Get the start of the next line, so that words that wrap to the next
  	 * line are found too: "et<line-break>al.".
  	 * Trick: skip a few chars for C/shell/Vim comments */
  	nextline[SPWORDLEN] = NUL;
  	if (lnum < wp->w_buffer->b_ml.ml_line_count)
  	{
  	    line = ml_get_buf(wp->w_buffer, lnum + 1, FALSE);
  	    spell_cat_line(nextline + SPWORDLEN, line, SPWORDLEN);
  	}
  
  	/* When a word wrapped from the previous line the start of the current
  	 * line is valid. */
  	if (lnum == checked_lnum)
  	    cur_checked_col = checked_col;
  	checked_lnum = 0;
  
  	/* When there was a sentence end in the previous line may require a
  	 * word starting with capital in this line.  In line 1 always check
  	 * the first word. */
  	if (lnum != capcol_lnum)
  	    cap_col = -1;
  	if (lnum == 1)
  	    cap_col = 0;
  	capcol_lnum = 0;
      }
  #endif
  
      /*
       * handle visual active in this window
       */
      fromcol = -10;
      tocol = MAXCOL;
      if (VIsual_active && wp->w_buffer == curwin->w_buffer)
      {
  					/* Visual is after curwin->w_cursor */
  	if (LTOREQ_POS(curwin->w_cursor, VIsual))
  	{
  	    top = &curwin->w_cursor;
  	    bot = &VIsual;
  	}
  	else				/* Visual is before curwin->w_cursor */
  	{
  	    top = &VIsual;
  	    bot = &curwin->w_cursor;
  	}
  	lnum_in_visual_area = (lnum >= top->lnum && lnum <= bot->lnum);
  	if (VIsual_mode == Ctrl_V)	/* block mode */
  	{
  	    if (lnum_in_visual_area)
  	    {
  		fromcol = wp->w_old_cursor_fcol;
  		tocol = wp->w_old_cursor_lcol;
  	    }
  	}
  	else				/* non-block mode */
  	{
  	    if (lnum > top->lnum && lnum <= bot->lnum)
  		fromcol = 0;
  	    else if (lnum == top->lnum)
  	    {
  		if (VIsual_mode == 'V')	/* linewise */
  		    fromcol = 0;
  		else
  		{
  		    getvvcol(wp, top, (colnr_T *)&fromcol, NULL, NULL);
  		    if (gchar_pos(top) == NUL)
  			tocol = fromcol + 1;
  		}
  	    }
  	    if (VIsual_mode != 'V' && lnum == bot->lnum)
  	    {
  		if (*p_sel == 'e' && bot->col == 0
  #ifdef FEAT_VIRTUALEDIT
  			&& bot->coladd == 0
  #endif
  		   )
  		{
  		    fromcol = -10;
  		    tocol = MAXCOL;
  		}
  		else if (bot->col == MAXCOL)
  		    tocol = MAXCOL;
  		else
  		{
  		    pos = *bot;
  		    if (*p_sel == 'e')
  			getvvcol(wp, &pos, (colnr_T *)&tocol, NULL, NULL);
  		    else
  		    {
  			getvvcol(wp, &pos, NULL, NULL, (colnr_T *)&tocol);
  			++tocol;
  		    }
  		}
  	    }
  	}
  
  	/* Check if the character under the cursor should not be inverted */
  	if (!highlight_match && lnum == curwin->w_cursor.lnum && wp == curwin
  #ifdef FEAT_GUI
  		&& !gui.in_use
  #endif
  		)
  	    noinvcur = TRUE;
  
  	/* if inverting in this line set area_highlighting */
  	if (fromcol >= 0)
  	{
  	    area_highlighting = TRUE;
  	    attr = HL_ATTR(HLF_V);
  #if defined(FEAT_CLIPBOARD) && defined(FEAT_X11)
  	    if ((clip_star.available && !clip_star.owned
  						     && clip_isautosel_star())
  		    || (clip_plus.available && !clip_plus.owned
  						    && clip_isautosel_plus()))
  		attr = HL_ATTR(HLF_VNC);
  #endif
  	}
      }
  
      /*
       * handle 'incsearch' and ":s///c" highlighting
       */
      else if (highlight_match
  	    && wp == curwin
  	    && lnum >= curwin->w_cursor.lnum
  	    && lnum <= curwin->w_cursor.lnum + search_match_lines)
      {
  	if (lnum == curwin->w_cursor.lnum)
  	    getvcol(curwin, &(curwin->w_cursor),
  					     (colnr_T *)&fromcol, NULL, NULL);
  	else
  	    fromcol = 0;
  	if (lnum == curwin->w_cursor.lnum + search_match_lines)
  	{
  	    pos.lnum = lnum;
  	    pos.col = search_match_endcol;
  	    getvcol(curwin, &pos, (colnr_T *)&tocol, NULL, NULL);
  	}
  	else
  	    tocol = MAXCOL;
  	/* do at least one character; happens when past end of line */
  	if (fromcol == tocol)
  	    tocol = fromcol + 1;
  	area_highlighting = TRUE;
  	attr = HL_ATTR(HLF_I);
      }
  
  #ifdef FEAT_DIFF
      filler_lines = diff_check(wp, lnum);
      if (filler_lines < 0)
      {
  	if (filler_lines == -1)
  	{
  	    if (diff_find_change(wp, lnum, &change_start, &change_end))
  		diff_hlf = HLF_ADD;	/* added line */
  	    else if (change_start == 0)
  		diff_hlf = HLF_TXD;	/* changed text */
  	    else
  		diff_hlf = HLF_CHD;	/* changed line */
  	}
  	else
  	    diff_hlf = HLF_ADD;		/* added line */
  	filler_lines = 0;
  	area_highlighting = TRUE;
      }
      if (lnum == wp->w_topline)
  	filler_lines = wp->w_topfill;
      filler_todo = filler_lines;
  #endif
  
  #ifdef LINE_ATTR
  # ifdef FEAT_SIGNS
      /* If this line has a sign with line highlighting set line_attr. */
      v = buf_getsigntype(wp->w_buffer, lnum, SIGN_LINEHL);
      if (v != 0)
  	line_attr = sign_get_attr((int)v, TRUE);
  # endif
  # if defined(FEAT_QUICKFIX)
      /* Highlight the current line in the quickfix window. */
      if (bt_quickfix(wp->w_buffer) && qf_current_entry(wp) == lnum)
  	line_attr = HL_ATTR(HLF_QFL);
  # endif
      if (line_attr != 0)
  	area_highlighting = TRUE;
  #endif
  
      line = ml_get_buf(wp->w_buffer, lnum, FALSE);
      ptr = line;
  
  #ifdef FEAT_SPELL
      if (has_spell)
      {
  	/* For checking first word with a capital skip white space. */
  	if (cap_col == 0)
  	    cap_col = getwhitecols(line);
  
  	/* To be able to spell-check over line boundaries copy the end of the
  	 * current line into nextline[].  Above the start of the next line was
  	 * copied to nextline[SPWORDLEN]. */
  	if (nextline[SPWORDLEN] == NUL)
  	{
  	    /* No next line or it is empty. */
  	    nextlinecol = MAXCOL;
  	    nextline_idx = 0;
  	}
  	else
  	{
  	    v = (long)STRLEN(line);
  	    if (v < SPWORDLEN)
  	    {
  		/* Short line, use it completely and append the start of the
  		 * next line. */
  		nextlinecol = 0;
  		mch_memmove(nextline, line, (size_t)v);
  		STRMOVE(nextline + v, nextline + SPWORDLEN);
  		nextline_idx = v + 1;
  	    }
  	    else
  	    {
  		/* Long line, use only the last SPWORDLEN bytes. */
  		nextlinecol = v - SPWORDLEN;
  		mch_memmove(nextline, line + nextlinecol, SPWORDLEN);
  		nextline_idx = SPWORDLEN + 1;
  	    }
  	}
      }
  #endif
  
      if (wp->w_p_list)
      {
  	if (lcs_space || lcs_trail)
  	    extra_check = TRUE;
  	/* find start of trailing whitespace */
  	if (lcs_trail)
  	{
  	    trailcol = (colnr_T)STRLEN(ptr);
  	    while (trailcol > (colnr_T)0 && VIM_ISWHITE(ptr[trailcol - 1]))
  		--trailcol;
  	    trailcol += (colnr_T) (ptr - line);
  	}
      }
  
      /*
       * 'nowrap' or 'wrap' and a single line that doesn't fit: Advance to the
       * first character to be displayed.
       */
      if (wp->w_p_wrap)
  	v = wp->w_skipcol;
      else
  	v = wp->w_leftcol;
      if (v > 0)
      {
  #ifdef FEAT_MBYTE
  	char_u	*prev_ptr = ptr;
  #endif
  	while (vcol < v && *ptr != NUL)
  	{
  	    c = win_lbr_chartabsize(wp, line, ptr, (colnr_T)vcol, NULL);
  	    vcol += c;
  #ifdef FEAT_MBYTE
  	    prev_ptr = ptr;
  #endif
  	    MB_PTR_ADV(ptr);
  	}
  
  	/* When:
  	 * - 'cuc' is set, or
  	 * - 'colorcolumn' is set, or
  	 * - 'virtualedit' is set, or
  	 * - the visual mode is active,
  	 * the end of the line may be before the start of the displayed part.
  	 */
  	if (vcol < v && (
  #ifdef FEAT_SYN_HL
  	     wp->w_p_cuc || draw_color_col ||
  #endif
  #ifdef FEAT_VIRTUALEDIT
  	     virtual_active() ||
  #endif
  	     (VIsual_active && wp->w_buffer == curwin->w_buffer)))
  	{
  	    vcol = v;
  	}
  
  	/* Handle a character that's not completely on the screen: Put ptr at
  	 * that character but skip the first few screen characters. */
  	if (vcol > v)
  	{
  	    vcol -= c;
  #ifdef FEAT_MBYTE
  	    ptr = prev_ptr;
  #else
  	    --ptr;
  #endif
  	    /* If the character fits on the screen, don't need to skip it.
  	     * Except for a TAB. */
  	    if ((
  #ifdef FEAT_MBYTE
  			(*mb_ptr2cells)(ptr) >= c ||
  #endif
  		       *ptr == TAB) && col == 0)
  	       n_skip = v - vcol;
  	}
  
  	/*
  	 * Adjust for when the inverted text is before the screen,
  	 * and when the start of the inverted text is before the screen.
  	 */
  	if (tocol <= vcol)
  	    fromcol = 0;
  	else if (fromcol >= 0 && fromcol < vcol)
  	    fromcol = vcol;
  
  #ifdef FEAT_LINEBREAK
  	/* When w_skipcol is non-zero, first line needs 'showbreak' */
  	if (wp->w_p_wrap)
  	    need_showbreak = TRUE;
  #endif
  #ifdef FEAT_SPELL
  	/* When spell checking a word we need to figure out the start of the
  	 * word and if it's badly spelled or not. */
  	if (has_spell)
  	{
  	    int		len;
  	    colnr_T	linecol = (colnr_T)(ptr - line);
  	    hlf_T	spell_hlf = HLF_COUNT;
  
  	    pos = wp->w_cursor;
  	    wp->w_cursor.lnum = lnum;
  	    wp->w_cursor.col = linecol;
  	    len = spell_move_to(wp, FORWARD, TRUE, TRUE, &spell_hlf);
  
  	    /* spell_move_to() may call ml_get() and make "line" invalid */
  	    line = ml_get_buf(wp->w_buffer, lnum, FALSE);
  	    ptr = line + linecol;
  
  	    if (len == 0 || (int)wp->w_cursor.col > ptr - line)
  	    {
  		/* no bad word found at line start, don't check until end of a
  		 * word */
  		spell_hlf = HLF_COUNT;
  		word_end = (int)(spell_to_word_end(ptr, wp) - line + 1);
  	    }
  	    else
  	    {
  		/* bad word found, use attributes until end of word */
  		word_end = wp->w_cursor.col + len + 1;
  
  		/* Turn index into actual attributes. */
  		if (spell_hlf != HLF_COUNT)
  		    spell_attr = highlight_attr[spell_hlf];
  	    }
  	    wp->w_cursor = pos;
  
  # ifdef FEAT_SYN_HL
  	    /* Need to restart syntax highlighting for this line. */
  	    if (has_syntax)
  		syntax_start(wp, lnum);
  # endif
  	}
  #endif
      }
  
      /*
       * Correct highlighting for cursor that can't be disabled.
       * Avoids having to check this for each character.
       */
      if (fromcol >= 0)
      {
  	if (noinvcur)
  	{
  	    if ((colnr_T)fromcol == wp->w_virtcol)
  	    {
  		/* highlighting starts at cursor, let it start just after the
  		 * cursor */
  		fromcol_prev = fromcol;
  		fromcol = -1;
  	    }
  	    else if ((colnr_T)fromcol < wp->w_virtcol)
  		/* restart highlighting after the cursor */
  		fromcol_prev = wp->w_virtcol;
  	}
  	if (fromcol >= tocol)
  	    fromcol = -1;
      }
  
  #ifdef FEAT_SEARCH_EXTRA
      /*
       * Handle highlighting the last used search pattern and matches.
       * Do this for both search_hl and the match list.
       */
      cur = wp->w_match_head;
      shl_flag = FALSE;
      while (cur != NULL || shl_flag == FALSE)
      {
  	if (shl_flag == FALSE)
  	{
  	    shl = &search_hl;
  	    shl_flag = TRUE;
  	}
  	else
  	    shl = &cur->hl;
  	shl->startcol = MAXCOL;
  	shl->endcol = MAXCOL;
  	shl->attr_cur = 0;
  	shl->is_addpos = FALSE;
  	v = (long)(ptr - line);
  	if (cur != NULL)
  	    cur->pos.cur = 0;
  	next_search_hl(wp, shl, lnum, (colnr_T)v,
  					       shl == &search_hl ? NULL : cur);
  
  	/* Need to get the line again, a multi-line regexp may have made it
  	 * invalid. */
  	line = ml_get_buf(wp->w_buffer, lnum, FALSE);
  	ptr = line + v;
  
  	if (shl->lnum != 0 && shl->lnum <= lnum)
  	{
  	    if (shl->lnum == lnum)
  		shl->startcol = shl->rm.startpos[0].col;
  	    else
  		shl->startcol = 0;
  	    if (lnum == shl->lnum + shl->rm.endpos[0].lnum
  						- shl->rm.startpos[0].lnum)
  		shl->endcol = shl->rm.endpos[0].col;
  	    else
  		shl->endcol = MAXCOL;
  	    /* Highlight one character for an empty match. */
  	    if (shl->startcol == shl->endcol)
  	    {
  #ifdef FEAT_MBYTE
  		if (has_mbyte && line[shl->endcol] != NUL)
  		    shl->endcol += (*mb_ptr2len)(line + shl->endcol);
  		else
  #endif
  		    ++shl->endcol;
  	    }
  	    if ((long)shl->startcol < v)  /* match at leftcol */
  	    {
  		shl->attr_cur = shl->attr;
  		search_attr = shl->attr;
  	    }
  	    area_highlighting = TRUE;
  	}
  	if (shl != &search_hl && cur != NULL)
  	    cur = cur->next;
      }
  #endif
  
  #ifdef FEAT_SYN_HL
      /* Cursor line highlighting for 'cursorline' in the current window.  Not
       * when Visual mode is active, because it's not clear what is selected
       * then. */
      if (wp->w_p_cul && lnum == wp->w_cursor.lnum
  					 && !(wp == curwin && VIsual_active))
      {
  	line_attr = HL_ATTR(HLF_CUL);
  	area_highlighting = TRUE;
      }
  #endif
  
      off = (unsigned)(current_ScreenLine - ScreenLines);
      col = 0;
  #ifdef FEAT_RIGHTLEFT
      if (wp->w_p_rl)
      {
  	/* Rightleft window: process the text in the normal direction, but put
  	 * it in current_ScreenLine[] from right to left.  Start at the
  	 * rightmost column of the window. */
  	col = wp->w_width - 1;
  	off += col;
      }
  #endif
  
      /*
       * Repeat for the whole displayed line.
       */
      for (;;)
      {
  #ifdef FEAT_CONCEAL
  	has_match_conc = 0;
  #endif
  	/* Skip this quickly when working on the text. */
  	if (draw_state != WL_LINE)
  	{
  #ifdef FEAT_CMDWIN
  	    if (draw_state == WL_CMDLINE - 1 && n_extra == 0)
  	    {
  		draw_state = WL_CMDLINE;
  		if (cmdwin_type != 0 && wp == curwin)
  		{
  		    /* Draw the cmdline character. */
  		    n_extra = 1;
  		    c_extra = cmdwin_type;
  		    char_attr = HL_ATTR(HLF_AT);
  		}
  	    }
  #endif
  
  #ifdef FEAT_FOLDING
  	    if (draw_state == WL_FOLD - 1 && n_extra == 0)
  	    {
  		int fdc = compute_foldcolumn(wp, 0);
  
  		draw_state = WL_FOLD;
  		if (fdc > 0)
  		{
  		    /* Draw the 'foldcolumn'.  Allocate a buffer, "extra" may
  		     * already be in use. */
  		    vim_free(p_extra_free);
  		    p_extra_free = alloc(12 + 1);
  
  		    if (p_extra_free != NULL)
  		    {
  			fill_foldcolumn(p_extra_free, wp, FALSE, lnum);
  			n_extra = fdc;
  			p_extra_free[n_extra] = NUL;
  			p_extra = p_extra_free;
  			c_extra = NUL;
  			char_attr = HL_ATTR(HLF_FC);
  		    }
  		}
  	    }
  #endif
  
  #ifdef FEAT_SIGNS
  	    if (draw_state == WL_SIGN - 1 && n_extra == 0)
  	    {
  		draw_state = WL_SIGN;
  		/* Show the sign column when there are any signs in this
  		 * buffer or when using Netbeans. */
  		if (signcolumn_on(wp))
  		{
  		    int	text_sign;
  # ifdef FEAT_SIGN_ICONS
  		    int	icon_sign;
  # endif
  
  		    /* Draw two cells with the sign value or blank. */
  		    c_extra = ' ';
  		    char_attr = HL_ATTR(HLF_SC);
  		    n_extra = 2;
  
  		    if (row == startrow
  #ifdef FEAT_DIFF
  			    + filler_lines && filler_todo <= 0
  #endif
  			    )
  		    {
  			text_sign = buf_getsigntype(wp->w_buffer, lnum,
  								   SIGN_TEXT);
  # ifdef FEAT_SIGN_ICONS
  			icon_sign = buf_getsigntype(wp->w_buffer, lnum,
  								   SIGN_ICON);
  			if (gui.in_use && icon_sign != 0)
  			{
  			    /* Use the image in this position. */
  			    c_extra = SIGN_BYTE;
  #  ifdef FEAT_NETBEANS_INTG
  			    if (buf_signcount(wp->w_buffer, lnum) > 1)
  				c_extra = MULTISIGN_BYTE;
  #  endif
  			    char_attr = icon_sign;
  			}
  			else
  # endif
  			    if (text_sign != 0)
  			{
  			    p_extra = sign_get_text(text_sign);
  			    if (p_extra != NULL)
  			    {
  				c_extra = NUL;
  				n_extra = (int)STRLEN(p_extra);
  			    }
  			    char_attr = sign_get_attr(text_sign, FALSE);
  			}
  		    }
  		}
  	    }
  #endif
  
  	    if (draw_state == WL_NR - 1 && n_extra == 0)
  	    {
  		draw_state = WL_NR;
  		/* Display the absolute or relative line number. After the
  		 * first fill with blanks when the 'n' flag isn't in 'cpo' */
  		if ((wp->w_p_nu || wp->w_p_rnu)
  			&& (row == startrow
  #ifdef FEAT_DIFF
  			    + filler_lines
  #endif
  			    || vim_strchr(p_cpo, CPO_NUMCOL) == NULL))
  		{
  		    /* Draw the line number (empty space after wrapping). */
  		    if (row == startrow
  #ifdef FEAT_DIFF
  			    + filler_lines
  #endif
  			    )
  		    {
  			long num;
  			char *fmt = "%*ld ";
  
  			if (wp->w_p_nu && !wp->w_p_rnu)
  			    /* 'number' + 'norelativenumber' */
  			    num = (long)lnum;
  			else
  			{
  			    /* 'relativenumber', don't use negative numbers */
  			    num = labs((long)get_cursor_rel_lnum(wp, lnum));
  			    if (num == 0 && wp->w_p_nu && wp->w_p_rnu)
  			    {
  				/* 'number' + 'relativenumber' */
  				num = lnum;
  				fmt = "%-*ld ";
  			    }
  			}
  
  			sprintf((char *)extra, fmt,
  						number_width(wp), num);
  			if (wp->w_skipcol > 0)
  			    for (p_extra = extra; *p_extra == ' '; ++p_extra)
  				*p_extra = '-';
  #ifdef FEAT_RIGHTLEFT
  			if (wp->w_p_rl)		    /* reverse line numbers */
  			    rl_mirror(extra);
  #endif
  			p_extra = extra;
  			c_extra = NUL;
  		    }
  		    else
  			c_extra = ' ';
  		    n_extra = number_width(wp) + 1;
  		    char_attr = HL_ATTR(HLF_N);
  #ifdef FEAT_SYN_HL
  		    /* When 'cursorline' is set highlight the line number of
  		     * the current line differently.
  		     * TODO: Can we use CursorLine instead of CursorLineNr
  		     * when CursorLineNr isn't set? */
  		    if ((wp->w_p_cul || wp->w_p_rnu)
  						 && lnum == wp->w_cursor.lnum)
  			char_attr = HL_ATTR(HLF_CLN);
  #endif
  		}
  	    }
  
  #ifdef FEAT_LINEBREAK
  	    if (wp->w_p_brisbr && draw_state == WL_BRI - 1
  					     && n_extra == 0 && *p_sbr != NUL)
  		/* draw indent after showbreak value */
  		draw_state = WL_BRI;
  	    else if (wp->w_p_brisbr && draw_state == WL_SBR && n_extra == 0)
  		/* After the showbreak, draw the breakindent */
  		draw_state = WL_BRI - 1;
  
  	    /* draw 'breakindent': indent wrapped text accordingly */
  	    if (draw_state == WL_BRI - 1 && n_extra == 0)
  	    {
  		draw_state = WL_BRI;
  		/* if need_showbreak is set, breakindent also applies */
  		if (wp->w_p_bri && n_extra == 0
  					 && (row != startrow || need_showbreak)
  # ifdef FEAT_DIFF
  			&& filler_lines == 0
  # endif
  		   )
  		{
  		    char_attr = 0;
  # ifdef FEAT_DIFF
  		    if (diff_hlf != (hlf_T)0)
  		    {
  			char_attr = HL_ATTR(diff_hlf);
  #  ifdef FEAT_SYN_HL
  			if (wp->w_p_cul && lnum == wp->w_cursor.lnum)
  			    char_attr = hl_combine_attr(char_attr,
  							    HL_ATTR(HLF_CUL));
  #  endif
  		    }
  # endif
  		    p_extra = NULL;
  		    c_extra = ' ';
  		    n_extra = get_breakindent_win(wp,
  				       ml_get_buf(wp->w_buffer, lnum, FALSE));
  		    /* Correct end of highlighted area for 'breakindent',
  		     * required when 'linebreak' is also set. */
  		    if (tocol == vcol)
  			tocol += n_extra;
  		}
  	    }
  #endif
  
  #if defined(FEAT_LINEBREAK) || defined(FEAT_DIFF)
  	    if (draw_state == WL_SBR - 1 && n_extra == 0)
  	    {
  		draw_state = WL_SBR;
  # ifdef FEAT_DIFF
  		if (filler_todo > 0)
  		{
  		    /* Draw "deleted" diff line(s). */
  		    if (char2cells(fill_diff) > 1)
  			c_extra = '-';
  		    else
  			c_extra = fill_diff;
  #  ifdef FEAT_RIGHTLEFT
  		    if (wp->w_p_rl)
  			n_extra = col + 1;
  		    else
  #  endif
  			n_extra = wp->w_width - col;
  		    char_attr = HL_ATTR(HLF_DED);
  		}
  # endif
  # ifdef FEAT_LINEBREAK
  		if (*p_sbr != NUL && need_showbreak)
  		{
  		    /* Draw 'showbreak' at the start of each broken line. */
  		    p_extra = p_sbr;
  		    c_extra = NUL;
  		    n_extra = (int)STRLEN(p_sbr);
  		    char_attr = HL_ATTR(HLF_AT);
  		    need_showbreak = FALSE;
  		    vcol_sbr = vcol + MB_CHARLEN(p_sbr);
  		    /* Correct end of highlighted area for 'showbreak',
  		     * required when 'linebreak' is also set. */
  		    if (tocol == vcol)
  			tocol += n_extra;
  #ifdef FEAT_SYN_HL
  		    /* combine 'showbreak' with 'cursorline' */
  		    if (wp->w_p_cul && lnum == wp->w_cursor.lnum)
  			char_attr = hl_combine_attr(char_attr,
  							    HL_ATTR(HLF_CUL));
  #endif
  		}
  # endif
  	    }
  #endif
  
  	    if (draw_state == WL_LINE - 1 && n_extra == 0)
  	    {
  		draw_state = WL_LINE;
  		if (saved_n_extra)
  		{
  		    /* Continue item from end of wrapped line. */
  		    n_extra = saved_n_extra;
  		    c_extra = saved_c_extra;
  		    p_extra = saved_p_extra;
  		    char_attr = saved_char_attr;
  		}
  		else
  		    char_attr = 0;
  	    }
  	}
  
  	/* When still displaying '$' of change command, stop at cursor */
  	if (dollar_vcol >= 0 && wp == curwin
  		   && lnum == wp->w_cursor.lnum && vcol >= (long)wp->w_virtcol
  #ifdef FEAT_DIFF
  				   && filler_todo <= 0
  #endif
  		)
  	{
  	    screen_line(screen_row, wp->w_wincol, col, -(int)wp->w_width,
  						    HAS_RIGHTLEFT(wp->w_p_rl));
  	    /* Pretend we have finished updating the window.  Except when
  	     * 'cursorcolumn' is set. */
  #ifdef FEAT_SYN_HL
  	    if (wp->w_p_cuc)
  		row = wp->w_cline_row + wp->w_cline_height;
  	    else
  #endif
  		row = wp->w_height;
  	    break;
  	}
  
  	if (draw_state == WL_LINE && area_highlighting)
  	{
  	    /* handle Visual or match highlighting in this line */
  	    if (vcol == fromcol
  #ifdef FEAT_MBYTE
  		    || (has_mbyte && vcol + 1 == fromcol && n_extra == 0
  			&& (*mb_ptr2cells)(ptr) > 1)
  #endif
  		    || ((int)vcol_prev == fromcol_prev
  			&& vcol_prev < vcol	/* not at margin */
  			&& vcol < tocol))
  		area_attr = attr;		/* start highlighting */
  	    else if (area_attr != 0
  		    && (vcol == tocol
  			|| (noinvcur && (colnr_T)vcol == wp->w_virtcol)))
  		area_attr = 0;			/* stop highlighting */
  
  #ifdef FEAT_SEARCH_EXTRA
  	    if (!n_extra)
  	    {
  		/*
  		 * Check for start/end of search pattern match.
  		 * After end, check for start/end of next match.
  		 * When another match, have to check for start again.
  		 * Watch out for matching an empty string!
  		 * Do this for 'search_hl' and the match list (ordered by
  		 * priority).
  		 */
  		v = (long)(ptr - line);
  		cur = wp->w_match_head;
  		shl_flag = FALSE;
  		while (cur != NULL || shl_flag == FALSE)
  		{
  		    if (shl_flag == FALSE
  			    && ((cur != NULL
  				    && cur->priority > SEARCH_HL_PRIORITY)
  				|| cur == NULL))
  		    {
  			shl = &search_hl;
  			shl_flag = TRUE;
  		    }
  		    else
  			shl = &cur->hl;
  		    if (cur != NULL)
  			cur->pos.cur = 0;
  		    pos_inprogress = TRUE;
  		    while (shl->rm.regprog != NULL
  					   || (cur != NULL && pos_inprogress))
  		    {
  			if (shl->startcol != MAXCOL
  				&& v >= (long)shl->startcol
  				&& v < (long)shl->endcol)
  			{
  #ifdef FEAT_MBYTE
  			    int tmp_col = v + MB_PTR2LEN(ptr);
  
  			    if (shl->endcol < tmp_col)
  				shl->endcol = tmp_col;
  #endif
  			    shl->attr_cur = shl->attr;
  #ifdef FEAT_CONCEAL
  			    if (cur != NULL && syn_name2id((char_u *)"Conceal")
  							       == cur->hlg_id)
  			    {
  				has_match_conc =
  					     v == (long)shl->startcol ? 2 : 1;
  				match_conc = cur->conceal_char;
  			    }
  			    else
  				has_match_conc = match_conc = 0;
  #endif
  			}
  			else if (v == (long)shl->endcol)
  			{
  			    shl->attr_cur = 0;
  			    next_search_hl(wp, shl, lnum, (colnr_T)v,
  					       shl == &search_hl ? NULL : cur);
  			    pos_inprogress = cur == NULL || cur->pos.cur == 0
  							       ? FALSE : TRUE;
  
  			    /* Need to get the line again, a multi-line regexp
  			     * may have made it invalid. */
  			    line = ml_get_buf(wp->w_buffer, lnum, FALSE);
  			    ptr = line + v;
  
  			    if (shl->lnum == lnum)
  			    {
  				shl->startcol = shl->rm.startpos[0].col;
  				if (shl->rm.endpos[0].lnum == 0)
  				    shl->endcol = shl->rm.endpos[0].col;
  				else
  				    shl->endcol = MAXCOL;
  
  				if (shl->startcol == shl->endcol)
  				{
  				    /* highlight empty match, try again after
  				     * it */
  #ifdef FEAT_MBYTE
  				    if (has_mbyte)
  					shl->endcol += (*mb_ptr2len)(line
  							       + shl->endcol);
  				    else
  #endif
  					++shl->endcol;
  				}
  
  				/* Loop to check if the match starts at the
  				 * current position */
  				continue;
  			    }
  			}
  			break;
  		    }
  		    if (shl != &search_hl && cur != NULL)
  			cur = cur->next;
  		}
  
  		/* Use attributes from match with highest priority among
  		 * 'search_hl' and the match list. */
  		search_attr = search_hl.attr_cur;
  		cur = wp->w_match_head;
  		shl_flag = FALSE;
  		while (cur != NULL || shl_flag == FALSE)
  		{
  		    if (shl_flag == FALSE
  			    && ((cur != NULL
  				    && cur->priority > SEARCH_HL_PRIORITY)
  				|| cur == NULL))
  		    {
  			shl = &search_hl;
  			shl_flag = TRUE;
  		    }
  		    else
  			shl = &cur->hl;
  		    if (shl->attr_cur != 0)
  			search_attr = shl->attr_cur;
  		    if (shl != &search_hl && cur != NULL)
  			cur = cur->next;
  		}
  		/* Only highlight one character after the last column. */
  		if (*ptr == NUL && (did_line_attr >= 1
  				    || (wp->w_p_list && lcs_eol_one == -1)))
  		    search_attr = 0;
  	    }
  #endif
  
  #ifdef FEAT_DIFF
  	    if (diff_hlf != (hlf_T)0)
  	    {
  		if (diff_hlf == HLF_CHD && ptr - line >= change_start
  							      && n_extra == 0)
  		    diff_hlf = HLF_TXD;		/* changed text */
  		if (diff_hlf == HLF_TXD && ptr - line > change_end
  							      && n_extra == 0)
  		    diff_hlf = HLF_CHD;		/* changed line */
  		line_attr = HL_ATTR(diff_hlf);
  		if (wp->w_p_cul && lnum == wp->w_cursor.lnum)
  		    line_attr = hl_combine_attr(line_attr, HL_ATTR(HLF_CUL));
  	    }
  #endif
  
  	    /* Decide which of the highlight attributes to use. */
  	    attr_pri = TRUE;
  #ifdef LINE_ATTR
  	    if (area_attr != 0)
  		char_attr = hl_combine_attr(line_attr, area_attr);
  	    else if (search_attr != 0)
  		char_attr = hl_combine_attr(line_attr, search_attr);
  		/* Use line_attr when not in the Visual or 'incsearch' area
  		 * (area_attr may be 0 when "noinvcur" is set). */
  	    else if (line_attr != 0 && ((fromcol == -10 && tocol == MAXCOL)
  				|| vcol < fromcol || vcol_prev < fromcol_prev
  				|| vcol >= tocol))
  		char_attr = line_attr;
  #else
  	    if (area_attr != 0)
  		char_attr = area_attr;
  	    else if (search_attr != 0)
  		char_attr = search_attr;
  #endif
  	    else
  	    {
  		attr_pri = FALSE;
  #ifdef FEAT_SYN_HL
  		if (has_syntax)
  		    char_attr = syntax_attr;
  		else
  #endif
  		    char_attr = 0;
  	    }
  	}
  
  	/*
  	 * Get the next character to put on the screen.
  	 */
  	/*
  	 * The "p_extra" points to the extra stuff that is inserted to
  	 * represent special characters (non-printable stuff) and other
  	 * things.  When all characters are the same, c_extra is used.
  	 * "p_extra" must end in a NUL to avoid mb_ptr2len() reads past
  	 * "p_extra[n_extra]".
  	 * For the '$' of the 'list' option, n_extra == 1, p_extra == "".
  	 */
  	if (n_extra > 0)
  	{
  	    if (c_extra != NUL)
  	    {
  		c = c_extra;
  #ifdef FEAT_MBYTE
  		mb_c = c;	/* doesn't handle non-utf-8 multi-byte! */
  		if (enc_utf8 && utf_char2len(c) > 1)
  		{
  		    mb_utf8 = TRUE;
  		    u8cc[0] = 0;
  		    c = 0xc0;
  		}
  		else
  		    mb_utf8 = FALSE;
  #endif
  	    }
  	    else
  	    {
  		c = *p_extra;
  #ifdef FEAT_MBYTE
  		if (has_mbyte)
  		{
  		    mb_c = c;
  		    if (enc_utf8)
  		    {
  			/* If the UTF-8 character is more than one byte:
  			 * Decode it into "mb_c". */
  			mb_l = utfc_ptr2len(p_extra);
  			mb_utf8 = FALSE;
  			if (mb_l > n_extra)
  			    mb_l = 1;
  			else if (mb_l > 1)
  			{
  			    mb_c = utfc_ptr2char(p_extra, u8cc);
  			    mb_utf8 = TRUE;
  			    c = 0xc0;
  			}
  		    }
  		    else
  		    {
  			/* if this is a DBCS character, put it in "mb_c" */
  			mb_l = MB_BYTE2LEN(c);
  			if (mb_l >= n_extra)
  			    mb_l = 1;
  			else if (mb_l > 1)
  			    mb_c = (c << 8) + p_extra[1];
  		    }
  		    if (mb_l == 0)  /* at the NUL at end-of-line */
  			mb_l = 1;
  
  		    /* If a double-width char doesn't fit display a '>' in the
  		     * last column. */
  		    if ((
  # ifdef FEAT_RIGHTLEFT
  			    wp->w_p_rl ? (col <= 0) :
  # endif
  				    (col >= wp->w_width - 1))
  			    && (*mb_char2cells)(mb_c) == 2)
  		    {
  			c = '>';
  			mb_c = c;
  			mb_l = 1;
  			mb_utf8 = FALSE;
  			multi_attr = HL_ATTR(HLF_AT);
  			/* put the pointer back to output the double-width
  			 * character at the start of the next line. */
  			++n_extra;
  			--p_extra;
  		    }
  		    else
  		    {
  			n_extra -= mb_l - 1;
  			p_extra += mb_l - 1;
  		    }
  		}
  #endif
  		++p_extra;
  	    }
  	    --n_extra;
  	}
  	else
  	{
  #ifdef FEAT_LINEBREAK
  	    int c0;
  #endif
  
  	    if (p_extra_free != NULL)
  		VIM_CLEAR(p_extra_free);
  	    /*
  	     * Get a character from the line itself.
  	     */
  	    c = *ptr;
  #ifdef FEAT_LINEBREAK
  	    c0 = *ptr;
  #endif
  #ifdef FEAT_MBYTE
  	    if (has_mbyte)
  	    {
  		mb_c = c;
  		if (enc_utf8)
  		{
  		    /* If the UTF-8 character is more than one byte: Decode it
  		     * into "mb_c". */
  		    mb_l = utfc_ptr2len(ptr);
  		    mb_utf8 = FALSE;
  		    if (mb_l > 1)
  		    {
  			mb_c = utfc_ptr2char(ptr, u8cc);
  			/* Overlong encoded ASCII or ASCII with composing char
  			 * is displayed normally, except a NUL. */
  			if (mb_c < 0x80)
  			{
  			    c = mb_c;
  # ifdef FEAT_LINEBREAK
  			    c0 = mb_c;
  # endif
  			}
  			mb_utf8 = TRUE;
  
  			/* At start of the line we can have a composing char.
  			 * Draw it as a space with a composing char. */
  			if (utf_iscomposing(mb_c))
  			{
  			    int i;
  
  			    for (i = Screen_mco - 1; i > 0; --i)
  				u8cc[i] = u8cc[i - 1];
  			    u8cc[0] = mb_c;
  			    mb_c = ' ';
  			}
  		    }
  
  		    if ((mb_l == 1 && c >= 0x80)
  			    || (mb_l >= 1 && mb_c == 0)
  			    || (mb_l > 1 && (!vim_isprintc(mb_c)
  # ifdef UNICODE16
  							 || mb_c >= 0x10000
  # endif
  							 )))
  		    {
  			/*
  			 * Illegal UTF-8 byte: display as <xx>.
  			 * Non-BMP character : display as ? or fullwidth ?.
  			 */
  # ifdef UNICODE16
  			if (mb_c < 0x10000)
  # endif
  			{
  			    transchar_hex(extra, mb_c);
  # ifdef FEAT_RIGHTLEFT
  			    if (wp->w_p_rl)		/* reverse */
  				rl_mirror(extra);
  # endif
  			}
  # ifdef UNICODE16
  			else if (utf_char2cells(mb_c) != 2)
  			    STRCPY(extra, "?");
  			else
  			    /* 0xff1f in UTF-8: full-width '?' */
  			    STRCPY(extra, "\357\274\237");
  # endif
  
  			p_extra = extra;
  			c = *p_extra;
  			mb_c = mb_ptr2char_adv(&p_extra);
  			mb_utf8 = (c >= 0x80);
  			n_extra = (int)STRLEN(p_extra);
  			c_extra = NUL;
  			if (area_attr == 0 && search_attr == 0)
  			{
  			    n_attr = n_extra + 1;
  			    extra_attr = HL_ATTR(HLF_8);
  			    saved_attr2 = char_attr; /* save current attr */
  			}
  		    }
  		    else if (mb_l == 0)  /* at the NUL at end-of-line */
  			mb_l = 1;
  #ifdef FEAT_ARABIC
  		    else if (p_arshape && !p_tbidi && ARABIC_CHAR(mb_c))
  		    {
  			/* Do Arabic shaping. */
  			int	pc, pc1, nc;
  			int	pcc[MAX_MCO];
  
  			/* The idea of what is the previous and next
  			 * character depends on 'rightleft'. */
  			if (wp->w_p_rl)
  			{
  			    pc = prev_c;
  			    pc1 = prev_c1;
  			    nc = utf_ptr2char(ptr + mb_l);
  			    prev_c1 = u8cc[0];
  			}
  			else
  			{
  			    pc = utfc_ptr2char(ptr + mb_l, pcc);
  			    nc = prev_c;
  			    pc1 = pcc[0];
  			}
  			prev_c = mb_c;
  
  			mb_c = arabic_shape(mb_c, &c, &u8cc[0], pc, pc1, nc);
  		    }
  		    else
  			prev_c = mb_c;
  #endif
  		}
  		else	/* enc_dbcs */
  		{
  		    mb_l = MB_BYTE2LEN(c);
  		    if (mb_l == 0)  /* at the NUL at end-of-line */
  			mb_l = 1;
  		    else if (mb_l > 1)
  		    {
  			/* We assume a second byte below 32 is illegal.
  			 * Hopefully this is OK for all double-byte encodings!
  			 */
  			if (ptr[1] >= 32)
  			    mb_c = (c << 8) + ptr[1];
  			else
  			{
  			    if (ptr[1] == NUL)
  			    {
  				/* head byte at end of line */
  				mb_l = 1;
  				transchar_nonprint(extra, c);
  			    }
  			    else
  			    {
  				/* illegal tail byte */
  				mb_l = 2;
  				STRCPY(extra, "XX");
  			    }
  			    p_extra = extra;
  			    n_extra = (int)STRLEN(extra) - 1;
  			    c_extra = NUL;
  			    c = *p_extra++;
  			    if (area_attr == 0 && search_attr == 0)
  			    {
  				n_attr = n_extra + 1;
  				extra_attr = HL_ATTR(HLF_8);
  				saved_attr2 = char_attr; /* save current attr */
  			    }
  			    mb_c = c;
  			}
  		    }
  		}
  		/* If a double-width char doesn't fit display a '>' in the
  		 * last column; the character is displayed at the start of the
  		 * next line. */
  		if ((
  # ifdef FEAT_RIGHTLEFT
  			    wp->w_p_rl ? (col <= 0) :
  # endif
  				(col >= wp->w_width - 1))
  			&& (*mb_char2cells)(mb_c) == 2)
  		{
  		    c = '>';
  		    mb_c = c;
  		    mb_utf8 = FALSE;
  		    mb_l = 1;
  		    multi_attr = HL_ATTR(HLF_AT);
  		    /* Put pointer back so that the character will be
  		     * displayed at the start of the next line. */
  		    --ptr;
  		}
  		else if (*ptr != NUL)
  		    ptr += mb_l - 1;
  
  		/* If a double-width char doesn't fit at the left side display
  		 * a '<' in the first column.  Don't do this for unprintable
  		 * characters. */
  		if (n_skip > 0 && mb_l > 1 && n_extra == 0)
  		{
  		    n_extra = 1;
  		    c_extra = MB_FILLER_CHAR;
  		    c = ' ';
  		    if (area_attr == 0 && search_attr == 0)
  		    {
  			n_attr = n_extra + 1;
  			extra_attr = HL_ATTR(HLF_AT);
  			saved_attr2 = char_attr; /* save current attr */
  		    }
  		    mb_c = c;
  		    mb_utf8 = FALSE;
  		    mb_l = 1;
  		}
  
  	    }
  #endif
  	    ++ptr;
  
  	    if (extra_check)
  	    {
  #ifdef FEAT_SPELL
  		int	can_spell = TRUE;
  #endif
  
  #ifdef FEAT_TERMINAL
  		if (get_term_attr)
  		{
  		    syntax_attr = term_get_attr(wp->w_buffer, lnum, vcol);
  
  		    if (!attr_pri)
  			char_attr = syntax_attr;
  		    else
  			char_attr = hl_combine_attr(syntax_attr, char_attr);
  		}
  #endif
  
  #ifdef FEAT_SYN_HL
  		/* Get syntax attribute, unless still at the start of the line
  		 * (double-wide char that doesn't fit). */
  		v = (long)(ptr - line);
  		if (has_syntax && v > 0)
  		{
  		    /* Get the syntax attribute for the character.  If there
  		     * is an error, disable syntax highlighting. */
  		    save_did_emsg = did_emsg;
  		    did_emsg = FALSE;
  
  		    syntax_attr = get_syntax_attr((colnr_T)v - 1,
  # ifdef FEAT_SPELL
  						has_spell ? &can_spell :
  # endif
  						NULL, FALSE);
  
  		    if (did_emsg)
  		    {
  			wp->w_s->b_syn_error = TRUE;
  			has_syntax = FALSE;
  		    }
  		    else
  			did_emsg = save_did_emsg;
  #ifdef SYN_TIME_LIMIT
  		    if (wp->w_s->b_syn_slow)
  			has_syntax = FALSE;
  #endif
  
  		    /* Need to get the line again, a multi-line regexp may
  		     * have made it invalid. */
  		    line = ml_get_buf(wp->w_buffer, lnum, FALSE);
  		    ptr = line + v;
  
  		    if (!attr_pri)
  			char_attr = syntax_attr;
  		    else
  			char_attr = hl_combine_attr(syntax_attr, char_attr);
  # ifdef FEAT_CONCEAL
  		    /* no concealing past the end of the line, it interferes
  		     * with line highlighting */
  		    if (c == NUL)
  			syntax_flags = 0;
  		    else
  			syntax_flags = get_syntax_info(&syntax_seqnr);
  # endif
  		}
  #endif
  
  #ifdef FEAT_SPELL
  		/* Check spelling (unless at the end of the line).
  		 * Only do this when there is no syntax highlighting, the
  		 * @Spell cluster is not used or the current syntax item
  		 * contains the @Spell cluster. */
  		if (has_spell && v >= word_end && v > cur_checked_col)
  		{
  		    spell_attr = 0;
  # ifdef FEAT_SYN_HL
  		    if (!attr_pri)
  			char_attr = syntax_attr;
  # endif
  		    if (c != 0 && (
  # ifdef FEAT_SYN_HL
  				!has_syntax ||
  # endif
  				can_spell))
  		    {
  			char_u	*prev_ptr, *p;
  			int	len;
  			hlf_T	spell_hlf = HLF_COUNT;
  # ifdef FEAT_MBYTE
  			if (has_mbyte)
  			{
  			    prev_ptr = ptr - mb_l;
  			    v -= mb_l - 1;
  			}
  			else
  # endif
  			    prev_ptr = ptr - 1;
  
  			/* Use nextline[] if possible, it has the start of the
  			 * next line concatenated. */
  			if ((prev_ptr - line) - nextlinecol >= 0)
  			    p = nextline + (prev_ptr - line) - nextlinecol;
  			else
  			    p = prev_ptr;
  			cap_col -= (int)(prev_ptr - line);
  			len = spell_check(wp, p, &spell_hlf, &cap_col,
  								    nochange);
  			word_end = v + len;
  
  			/* In Insert mode only highlight a word that
  			 * doesn't touch the cursor. */
  			if (spell_hlf != HLF_COUNT
  				&& (State & INSERT) != 0
  				&& wp->w_cursor.lnum == lnum
  				&& wp->w_cursor.col >=
  						    (colnr_T)(prev_ptr - line)
  				&& wp->w_cursor.col < (colnr_T)word_end)
  			{
  			    spell_hlf = HLF_COUNT;
  			    spell_redraw_lnum = lnum;
  			}
  
  			if (spell_hlf == HLF_COUNT && p != prev_ptr
  				       && (p - nextline) + len > nextline_idx)
  			{
  			    /* Remember that the good word continues at the
  			     * start of the next line. */
  			    checked_lnum = lnum + 1;
  			    checked_col = (int)((p - nextline) + len - nextline_idx);
  			}
  
  			/* Turn index into actual attributes. */
  			if (spell_hlf != HLF_COUNT)
  			    spell_attr = highlight_attr[spell_hlf];
  
  			if (cap_col > 0)
  			{
  			    if (p != prev_ptr
  				   && (p - nextline) + cap_col >= nextline_idx)
  			    {
  				/* Remember that the word in the next line
  				 * must start with a capital. */
  				capcol_lnum = lnum + 1;
  				cap_col = (int)((p - nextline) + cap_col
  							       - nextline_idx);
  			    }
  			    else
  				/* Compute the actual column. */
  				cap_col += (int)(prev_ptr - line);
  			}
  		    }
  		}
  		if (spell_attr != 0)
  		{
  		    if (!attr_pri)
  			char_attr = hl_combine_attr(char_attr, spell_attr);
  		    else
  			char_attr = hl_combine_attr(spell_attr, char_attr);
  		}
  #endif
  #ifdef FEAT_LINEBREAK
  		/*
  		 * Found last space before word: check for line break.
  		 */
  		if (wp->w_p_lbr && c0 == c
  				  && VIM_ISBREAK(c) && !VIM_ISBREAK((int)*ptr))
  		{
  # ifdef FEAT_MBYTE
  		    int mb_off = has_mbyte ? (*mb_head_off)(line, ptr - 1) : 0;
  # endif
  		    char_u *p = ptr - (
  # ifdef FEAT_MBYTE
  				mb_off +
  # endif
  				1);
  
  		    /* TODO: is passing p for start of the line OK? */
  		    n_extra = win_lbr_chartabsize(wp, line, p, (colnr_T)vcol,
  								    NULL) - 1;
  		    if (c == TAB && n_extra + col > wp->w_width)
  			n_extra = (int)wp->w_buffer->b_p_ts
  				       - vcol % (int)wp->w_buffer->b_p_ts - 1;
  
  # ifdef FEAT_MBYTE
  		    c_extra = mb_off > 0 ? MB_FILLER_CHAR : ' ';
  # else
  		    c_extra = ' ';
  # endif
  		    if (VIM_ISWHITE(c))
  		    {
  #ifdef FEAT_CONCEAL
  			if (c == TAB)
  			    /* See "Tab alignment" below. */
  			    FIX_FOR_BOGUSCOLS;
  #endif
  			if (!wp->w_p_list)
  			    c = ' ';
  		    }
  		}
  #endif
  
  		/* 'list': change char 160 to lcs_nbsp and space to lcs_space.
  		 */
  		if (wp->w_p_list
  			&& (((c == 160
  #ifdef FEAT_MBYTE
  			      || (mb_utf8 && (mb_c == 160 || mb_c == 0x202f))
  #endif
  			     ) && lcs_nbsp)
  			|| (c == ' ' && lcs_space && ptr - line <= trailcol)))
  		{
  		    c = (c == ' ') ? lcs_space : lcs_nbsp;
  		    if (area_attr == 0 && search_attr == 0)
  		    {
  			n_attr = 1;
  			extra_attr = HL_ATTR(HLF_8);
  			saved_attr2 = char_attr; /* save current attr */
  		    }
  #ifdef FEAT_MBYTE
  		    mb_c = c;
  		    if (enc_utf8 && utf_char2len(c) > 1)
  		    {
  			mb_utf8 = TRUE;
  			u8cc[0] = 0;
  			c = 0xc0;
  		    }
  		    else
  			mb_utf8 = FALSE;
  #endif
  		}
  
  		if (trailcol != MAXCOL && ptr > line + trailcol && c == ' ')
  		{
  		    c = lcs_trail;
  		    if (!attr_pri)
  		    {
  			n_attr = 1;
  			extra_attr = HL_ATTR(HLF_8);
  			saved_attr2 = char_attr; /* save current attr */
  		    }
  #ifdef FEAT_MBYTE
  		    mb_c = c;
  		    if (enc_utf8 && utf_char2len(c) > 1)
  		    {
  			mb_utf8 = TRUE;
  			u8cc[0] = 0;
  			c = 0xc0;
  		    }
  		    else
  			mb_utf8 = FALSE;
  #endif
  		}
  	    }
  
  	    /*
  	     * Handling of non-printable characters.
  	     */
  	    if (!vim_isprintc(c))
  	    {
  		/*
  		 * when getting a character from the file, we may have to
  		 * turn it into something else on the way to putting it
  		 * into "ScreenLines".
  		 */
  		if (c == TAB && (!wp->w_p_list || lcs_tab1))
  		{
  		    int tab_len = 0;
  		    long vcol_adjusted = vcol; /* removed showbreak length */
  #ifdef FEAT_LINEBREAK
  		    /* only adjust the tab_len, when at the first column
  		     * after the showbreak value was drawn */
  		    if (*p_sbr != NUL && vcol == vcol_sbr && wp->w_p_wrap)
  			vcol_adjusted = vcol - MB_CHARLEN(p_sbr);
  #endif
  		    /* tab amount depends on current column */
  		    tab_len = (int)wp->w_buffer->b_p_ts
  					- vcol_adjusted % (int)wp->w_buffer->b_p_ts - 1;
  
  #ifdef FEAT_LINEBREAK
  		    if (!wp->w_p_lbr || !wp->w_p_list)
  #endif
  		    /* tab amount depends on current column */
  			n_extra = tab_len;
  #ifdef FEAT_LINEBREAK
  		    else
  		    {
  			char_u *p;
  			int	len = n_extra;
  			int	i;
  			int	saved_nextra = n_extra;
  
  #ifdef FEAT_CONCEAL
  			if (vcol_off > 0)
  			    /* there are characters to conceal */
  			    tab_len += vcol_off;
  			/* boguscols before FIX_FOR_BOGUSCOLS macro from above
  			 */
  			if (wp->w_p_list && lcs_tab1 && old_boguscols > 0
  							 && n_extra > tab_len)
  			    tab_len += n_extra - tab_len;
  #endif
  
  			/* if n_extra > 0, it gives the number of chars, to
  			 * use for a tab, else we need to calculate the width
  			 * for a tab */
  #ifdef FEAT_MBYTE
  			len = (tab_len * mb_char2len(lcs_tab2));
  			if (n_extra > 0)
  			    len += n_extra - tab_len;
  #endif
  			c = lcs_tab1;
  			p = alloc((unsigned)(len + 1));
  			vim_memset(p, ' ', len);
  			p[len] = NUL;
  			vim_free(p_extra_free);
  			p_extra_free = p;
  			for (i = 0; i < tab_len; i++)
  			{
  #ifdef FEAT_MBYTE
  			    mb_char2bytes(lcs_tab2, p);
  			    p += mb_char2len(lcs_tab2);
  			    n_extra += mb_char2len(lcs_tab2)
  						 - (saved_nextra > 0 ? 1 : 0);
  #else
  			    p[i] = lcs_tab2;
  #endif
  			}
  			p_extra = p_extra_free;
  #ifdef FEAT_CONCEAL
  			/* n_extra will be increased by FIX_FOX_BOGUSCOLS
  			 * macro below, so need to adjust for that here */
  			if (vcol_off > 0)
  			    n_extra -= vcol_off;
  #endif
  		    }
  #endif
  #ifdef FEAT_CONCEAL
  		    {
  			int vc_saved = vcol_off;
  
  			/* Tab alignment should be identical regardless of
  			 * 'conceallevel' value. So tab compensates of all
  			 * previous concealed characters, and thus resets
  			 * vcol_off and boguscols accumulated so far in the
  			 * line. Note that the tab can be longer than
  			 * 'tabstop' when there are concealed characters. */
  			FIX_FOR_BOGUSCOLS;
  
  			/* Make sure, the highlighting for the tab char will be
  			 * correctly set further below (effectively reverts the
  			 * FIX_FOR_BOGSUCOLS macro */
  			if (n_extra == tab_len + vc_saved && wp->w_p_list
  								  && lcs_tab1)
  			    tab_len += vc_saved;
  		    }
  #endif
  #ifdef FEAT_MBYTE
  		    mb_utf8 = FALSE;	/* don't draw as UTF-8 */
  #endif
  		    if (wp->w_p_list)
  		    {
  			c = lcs_tab1;
  #ifdef FEAT_LINEBREAK
  			if (wp->w_p_lbr)
  			    c_extra = NUL; /* using p_extra from above */
  			else
  #endif
  			    c_extra = lcs_tab2;
  			n_attr = tab_len + 1;
  			extra_attr = HL_ATTR(HLF_8);
  			saved_attr2 = char_attr; /* save current attr */
  #ifdef FEAT_MBYTE
  			mb_c = c;
  			if (enc_utf8 && utf_char2len(c) > 1)
  			{
  			    mb_utf8 = TRUE;
  			    u8cc[0] = 0;
  			    c = 0xc0;
  			}
  #endif
  		    }
  		    else
  		    {
  			c_extra = ' ';
  			c = ' ';
  		    }
  		}
  		else if (c == NUL
  			&& (wp->w_p_list
  			    || ((fromcol >= 0 || fromcol_prev >= 0)
  				&& tocol > vcol
  				&& VIsual_mode != Ctrl_V
  				&& (
  # ifdef FEAT_RIGHTLEFT
  				    wp->w_p_rl ? (col >= 0) :
  # endif
  				    (col < wp->w_width))
  				&& !(noinvcur
  				    && lnum == wp->w_cursor.lnum
  				    && (colnr_T)vcol == wp->w_virtcol)))
  			&& lcs_eol_one > 0)
  		{
  		    /* Display a '$' after the line or highlight an extra
  		     * character if the line break is included. */
  #if defined(FEAT_DIFF) || defined(LINE_ATTR)
  		    /* For a diff line the highlighting continues after the
  		     * "$". */
  		    if (
  # ifdef FEAT_DIFF
  			    diff_hlf == (hlf_T)0
  #  ifdef LINE_ATTR
  			    &&
  #  endif
  # endif
  # ifdef LINE_ATTR
  			    line_attr == 0
  # endif
  		       )
  #endif
  		    {
  #ifdef FEAT_VIRTUALEDIT
  			/* In virtualedit, visual selections may extend
  			 * beyond end of line. */
  			if (area_highlighting && virtual_active()
  				&& tocol != MAXCOL && vcol < tocol)
  			    n_extra = 0;
  			else
  #endif
  			{
  			    p_extra = at_end_str;
  			    n_extra = 1;
  			    c_extra = NUL;
  			}
  		    }
  		    if (wp->w_p_list && lcs_eol > 0)
  			c = lcs_eol;
  		    else
  			c = ' ';
  		    lcs_eol_one = -1;
  		    --ptr;	    /* put it back at the NUL */
  		    if (!attr_pri)
  		    {
  			extra_attr = HL_ATTR(HLF_AT);
  			n_attr = 1;
  		    }
  #ifdef FEAT_MBYTE
  		    mb_c = c;
  		    if (enc_utf8 && utf_char2len(c) > 1)
  		    {
  			mb_utf8 = TRUE;
  			u8cc[0] = 0;
  			c = 0xc0;
  		    }
  		    else
  			mb_utf8 = FALSE;	/* don't draw as UTF-8 */
  #endif
  		}
  		else if (c != NUL)
  		{
  		    p_extra = transchar(c);
  		    if (n_extra == 0)
  			n_extra = byte2cells(c) - 1;
  #ifdef FEAT_RIGHTLEFT
  		    if ((dy_flags & DY_UHEX) && wp->w_p_rl)
  			rl_mirror(p_extra);	/* reverse "<12>" */
  #endif
  		    c_extra = NUL;
  #ifdef FEAT_LINEBREAK
  		    if (wp->w_p_lbr)
  		    {
  			char_u *p;
  
  			c = *p_extra;
  			p = alloc((unsigned)n_extra + 1);
  			vim_memset(p, ' ', n_extra);
  			STRNCPY(p, p_extra + 1, STRLEN(p_extra) - 1);
  			p[n_extra] = NUL;
  			vim_free(p_extra_free);
  			p_extra_free = p_extra = p;
  		    }
  		    else
  #endif
  		    {
  			n_extra = byte2cells(c) - 1;
  			c = *p_extra++;
  		    }
  		    if (!attr_pri)
  		    {
  			n_attr = n_extra + 1;
  			extra_attr = HL_ATTR(HLF_8);
  			saved_attr2 = char_attr; /* save current attr */
  		    }
  #ifdef FEAT_MBYTE
  		    mb_utf8 = FALSE;	/* don't draw as UTF-8 */
  #endif
  		}
  #ifdef FEAT_VIRTUALEDIT
  		else if (VIsual_active
  			 && (VIsual_mode == Ctrl_V
  			     || VIsual_mode == 'v')
  			 && virtual_active()
  			 && tocol != MAXCOL
  			 && vcol < tocol
  			 && (
  # ifdef FEAT_RIGHTLEFT
  			    wp->w_p_rl ? (col >= 0) :
  # endif
  			    (col < wp->w_width)))
  		{
  		    c = ' ';
  		    --ptr;	    /* put it back at the NUL */
  		}
  #endif
  #if defined(LINE_ATTR)
  		else if ((
  # ifdef FEAT_DIFF
  			    diff_hlf != (hlf_T)0 ||
  # endif
  # ifdef FEAT_TERMINAL
  			    term_attr != 0 ||
  # endif
  			    line_attr != 0
  			) && (
  # ifdef FEAT_RIGHTLEFT
  			    wp->w_p_rl ? (col >= 0) :
  # endif
  			    (col
  # ifdef FEAT_CONCEAL
  				- boguscols
  # endif
  					    < wp->w_width)))
  		{
  		    /* Highlight until the right side of the window */
  		    c = ' ';
  		    --ptr;	    /* put it back at the NUL */
  
  		    /* Remember we do the char for line highlighting. */
  		    ++did_line_attr;
  
  		    /* don't do search HL for the rest of the line */
  		    if (line_attr != 0 && char_attr == search_attr
  					&& (did_line_attr > 1
  					    || (wp->w_p_list && lcs_eol > 0)))
  			char_attr = line_attr;
  # ifdef FEAT_DIFF
  		    if (diff_hlf == HLF_TXD)
  		    {
  			diff_hlf = HLF_CHD;
  			if (attr == 0 || char_attr != attr)
  			{
  			    char_attr = HL_ATTR(diff_hlf);
  			    if (wp->w_p_cul && lnum == wp->w_cursor.lnum)
  				char_attr = hl_combine_attr(char_attr,
  							    HL_ATTR(HLF_CUL));
  			}
  		    }
  # endif
  # ifdef FEAT_TERMINAL
  		    if (term_attr != 0)
  		    {
  			char_attr = term_attr;
  			if (wp->w_p_cul && lnum == wp->w_cursor.lnum)
  			    char_attr = hl_combine_attr(char_attr,
  							    HL_ATTR(HLF_CUL));
  		    }
  # endif
  		}
  #endif
  	    }
  
  #ifdef FEAT_CONCEAL
  	    if (   wp->w_p_cole > 0
  		&& (wp != curwin || lnum != wp->w_cursor.lnum ||
  							conceal_cursor_line(wp) )
  		&& ( (syntax_flags & HL_CONCEAL) != 0 || has_match_conc > 0)
  		&& !(lnum_in_visual_area
  				    && vim_strchr(wp->w_p_cocu, 'v') == NULL))
  	    {
  		char_attr = conceal_attr;
  		if ((prev_syntax_id != syntax_seqnr || has_match_conc > 1)
  			&& (syn_get_sub_char() != NUL || match_conc
  							 || wp->w_p_cole == 1)
  			&& wp->w_p_cole != 3)
  		{
  		    /* First time at this concealed item: display one
  		     * character. */
  		    if (match_conc)
  			c = match_conc;
  		    else if (syn_get_sub_char() != NUL)
  			c = syn_get_sub_char();
  		    else if (lcs_conceal != NUL)
  			c = lcs_conceal;
  		    else
  			c = ' ';
  
  		    prev_syntax_id = syntax_seqnr;
  
  		    if (n_extra > 0)
  			vcol_off += n_extra;
  		    vcol += n_extra;
  		    if (wp->w_p_wrap && n_extra > 0)
  		    {
  # ifdef FEAT_RIGHTLEFT
  			if (wp->w_p_rl)
  			{
  			    col -= n_extra;
  			    boguscols -= n_extra;
  			}
  			else
  # endif
  			{
  			    boguscols += n_extra;
  			    col += n_extra;
  			}
  		    }
  		    n_extra = 0;
  		    n_attr = 0;
  		}
  		else if (n_skip == 0)
  		{
  		    is_concealing = TRUE;
  		    n_skip = 1;
  		}
  # ifdef FEAT_MBYTE
  		mb_c = c;
  		if (enc_utf8 && utf_char2len(c) > 1)
  		{
  		    mb_utf8 = TRUE;
  		    u8cc[0] = 0;
  		    c = 0xc0;
  		}
  		else
  		    mb_utf8 = FALSE;	/* don't draw as UTF-8 */
  # endif
  	    }
  	    else
  	    {
  		prev_syntax_id = 0;
  		is_concealing = FALSE;
  	    }
  #endif /* FEAT_CONCEAL */
  	}
  
  #ifdef FEAT_CONCEAL
  	/* In the cursor line and we may be concealing characters: correct
  	 * the cursor column when we reach its position. */
  	if (!did_wcol && draw_state == WL_LINE
  		&& wp == curwin && lnum == wp->w_cursor.lnum
  		&& conceal_cursor_line(wp)
  		&& (int)wp->w_virtcol <= vcol + n_skip)
  	{
  #  ifdef FEAT_RIGHTLEFT
  	    if (wp->w_p_rl)
  		wp->w_wcol = wp->w_width - col + boguscols - 1;
  	    else
  #  endif
  		wp->w_wcol = col - boguscols;
  	    wp->w_wrow = row;
  	    did_wcol = TRUE;
  	}
  #endif
  
  	/* Don't override visual selection highlighting. */
  	if (n_attr > 0
  		&& draw_state == WL_LINE
  		&& !attr_pri)
  	    char_attr = extra_attr;
  
  #if defined(FEAT_XIM) && defined(FEAT_GUI_GTK)
  	/* XIM don't send preedit_start and preedit_end, but they send
  	 * preedit_changed and commit.  Thus Vim can't set "im_is_active", use
  	 * im_is_preediting() here. */
  	if (p_imst == IM_ON_THE_SPOT
  		&& xic != NULL
  		&& lnum == wp->w_cursor.lnum
  		&& (State & INSERT)
  		&& !p_imdisable
  		&& im_is_preediting()
  		&& draw_state == WL_LINE)
  	{
  	    colnr_T tcol;
  
  	    if (preedit_end_col == MAXCOL)
  		getvcol(curwin, &(wp->w_cursor), &tcol, NULL, NULL);
  	    else
  		tcol = preedit_end_col;
  	    if ((long)preedit_start_col <= vcol && vcol < (long)tcol)
  	    {
  		if (feedback_old_attr < 0)
  		{
  		    feedback_col = 0;
  		    feedback_old_attr = char_attr;
  		}
  		char_attr = im_get_feedback_attr(feedback_col);
  		if (char_attr < 0)
  		    char_attr = feedback_old_attr;
  		feedback_col++;
  	    }
  	    else if (feedback_old_attr >= 0)
  	    {
  		char_attr = feedback_old_attr;
  		feedback_old_attr = -1;
  		feedback_col = 0;
  	    }
  	}
  #endif
  	/*
  	 * Handle the case where we are in column 0 but not on the first
  	 * character of the line and the user wants us to show us a
  	 * special character (via 'listchars' option "precedes:<char>".
  	 */
  	if (lcs_prec_todo != NUL
  		&& wp->w_p_list
  		&& (wp->w_p_wrap ? wp->w_skipcol > 0 : wp->w_leftcol > 0)
  #ifdef FEAT_DIFF
  		&& filler_todo <= 0
  #endif
  		&& draw_state > WL_NR
  		&& c != NUL)
  	{
  	    c = lcs_prec;
  	    lcs_prec_todo = NUL;
  #ifdef FEAT_MBYTE
  	    if (has_mbyte && (*mb_char2cells)(mb_c) > 1)
  	    {
  		/* Double-width character being overwritten by the "precedes"
  		 * character, need to fill up half the character. */
  		c_extra = MB_FILLER_CHAR;
  		n_extra = 1;
  		n_attr = 2;
  		extra_attr = HL_ATTR(HLF_AT);
  	    }
  	    mb_c = c;
  	    if (enc_utf8 && utf_char2len(c) > 1)
  	    {
  		mb_utf8 = TRUE;
  		u8cc[0] = 0;
  		c = 0xc0;
  	    }
  	    else
  		mb_utf8 = FALSE;	/* don't draw as UTF-8 */
  #endif
  	    if (!attr_pri)
  	    {
  		saved_attr3 = char_attr; /* save current attr */
  		char_attr = HL_ATTR(HLF_AT); /* later copied to char_attr */
  		n_attr3 = 1;
  	    }
  	}
  
  	/*
  	 * At end of the text line or just after the last character.
  	 */
  	if (c == NUL
  #if defined(LINE_ATTR)
  		|| did_line_attr == 1
  #endif
  		)
  	{
  #ifdef FEAT_SEARCH_EXTRA
  	    long prevcol = (long)(ptr - line) - (c == NUL);
  
  	    /* we're not really at that column when skipping some text */
  	    if ((long)(wp->w_p_wrap ? wp->w_skipcol : wp->w_leftcol) > prevcol)
  		++prevcol;
  #endif
  
  	    /* Invert at least one char, used for Visual and empty line or
  	     * highlight match at end of line. If it's beyond the last
  	     * char on the screen, just overwrite that one (tricky!)  Not
  	     * needed when a '$' was displayed for 'list'. */
  #ifdef FEAT_SEARCH_EXTRA
  	    prevcol_hl_flag = FALSE;
  	    if (!search_hl.is_addpos && prevcol == (long)search_hl.startcol)
  		prevcol_hl_flag = TRUE;
  	    else
  	    {
  		cur = wp->w_match_head;
  		while (cur != NULL)
  		{
  		    if (!cur->hl.is_addpos && prevcol == (long)cur->hl.startcol)
  		    {
  			prevcol_hl_flag = TRUE;
  			break;
  		    }
  		    cur = cur->next;
  		}
  	    }
  #endif
  	    if (lcs_eol == lcs_eol_one
  		    && ((area_attr != 0 && vcol == fromcol
  			    && (VIsual_mode != Ctrl_V
  				|| lnum == VIsual.lnum
  				|| lnum == curwin->w_cursor.lnum)
  			    && c == NUL)
  #ifdef FEAT_SEARCH_EXTRA
  			/* highlight 'hlsearch' match at end of line */
  			|| (prevcol_hl_flag == TRUE
  # ifdef FEAT_SYN_HL
  			    && !(wp->w_p_cul && lnum == wp->w_cursor.lnum
  				    && !(wp == curwin && VIsual_active))
  # endif
  # ifdef FEAT_DIFF
  			    && diff_hlf == (hlf_T)0
  # endif
  # if defined(LINE_ATTR)
  			    && did_line_attr <= 1
  # endif
  			   )
  #endif
  		       ))
  	    {
  		int n = 0;
  
  #ifdef FEAT_RIGHTLEFT
  		if (wp->w_p_rl)
  		{
  		    if (col < 0)
  			n = 1;
  		}
  		else
  #endif
  		{
  		    if (col >= wp->w_width)
  			n = -1;
  		}
  		if (n != 0)
  		{
  		    /* At the window boundary, highlight the last character
  		     * instead (better than nothing). */
  		    off += n;
  		    col += n;
  		}
  		else
  		{
  		    /* Add a blank character to highlight. */
  		    ScreenLines[off] = ' ';
  #ifdef FEAT_MBYTE
  		    if (enc_utf8)
  			ScreenLinesUC[off] = 0;
  #endif
  		}
  #ifdef FEAT_SEARCH_EXTRA
  		if (area_attr == 0)
  		{
  		    /* Use attributes from match with highest priority among
  		     * 'search_hl' and the match list. */
  		    char_attr = search_hl.attr;
  		    cur = wp->w_match_head;
  		    shl_flag = FALSE;
  		    while (cur != NULL || shl_flag == FALSE)
  		    {
  			if (shl_flag == FALSE
  				&& ((cur != NULL
  					&& cur->priority > SEARCH_HL_PRIORITY)
  				    || cur == NULL))
  			{
  			    shl = &search_hl;
  			    shl_flag = TRUE;
  			}
  			else
  			    shl = &cur->hl;
  			if ((ptr - line) - 1 == (long)shl->startcol
  				&& (shl == &search_hl || !shl->is_addpos))
  			    char_attr = shl->attr;
  			if (shl != &search_hl && cur != NULL)
  			    cur = cur->next;
  		    }
  		}
  #endif
  		ScreenAttrs[off] = char_attr;
  #ifdef FEAT_RIGHTLEFT
  		if (wp->w_p_rl)
  		{
  		    --col;
  		    --off;
  		}
  		else
  #endif
  		{
  		    ++col;
  		    ++off;
  		}
  		++vcol;
  #ifdef FEAT_SYN_HL
  		eol_hl_off = 1;
  #endif
  	    }
  	}
  
  	/*
  	 * At end of the text line.
  	 */
  	if (c == NUL)
  	{
  #ifdef FEAT_SYN_HL
  	    if (eol_hl_off > 0 && vcol - eol_hl_off == (long)wp->w_virtcol
  		    && lnum == wp->w_cursor.lnum)
  	    {
  		/* highlight last char after line */
  		--col;
  		--off;
  		--vcol;
  	    }
  
  	    /* Highlight 'cursorcolumn' & 'colorcolumn' past end of the line. */
  	    if (wp->w_p_wrap)
  		v = wp->w_skipcol;
  	    else
  		v = wp->w_leftcol;
  
  	    /* check if line ends before left margin */
  	    if (vcol < v + col - win_col_off(wp))
  		vcol = v + col - win_col_off(wp);
  #ifdef FEAT_CONCEAL
  	    /* Get rid of the boguscols now, we want to draw until the right
  	     * edge for 'cursorcolumn'. */
  	    col -= boguscols;
  	    boguscols = 0;
  #endif
  
  	    if (draw_color_col)
  		draw_color_col = advance_color_col(VCOL_HLC, &color_cols);
  
  	    if (((wp->w_p_cuc
  		      && (int)wp->w_virtcol >= VCOL_HLC - eol_hl_off
  		      && (int)wp->w_virtcol <
  					wp->w_width * (row - startrow + 1) + v
  		      && lnum != wp->w_cursor.lnum)
  		    || draw_color_col)
  # ifdef FEAT_RIGHTLEFT
  		    && !wp->w_p_rl
  # endif
  		    )
  	    {
  		int	rightmost_vcol = 0;
  		int	i;
  
  		if (wp->w_p_cuc)
  		    rightmost_vcol = wp->w_virtcol;
  		if (draw_color_col)
  		    /* determine rightmost colorcolumn to possibly draw */
  		    for (i = 0; color_cols[i] >= 0; ++i)
  			if (rightmost_vcol < color_cols[i])
  			    rightmost_vcol = color_cols[i];
  
  		while (col < wp->w_width)
  		{
  		    ScreenLines[off] = ' ';
  #ifdef FEAT_MBYTE
  		    if (enc_utf8)
  			ScreenLinesUC[off] = 0;
  #endif
  		    ++col;
  		    if (draw_color_col)
  			draw_color_col = advance_color_col(VCOL_HLC,
  								 &color_cols);
  
  		    if (wp->w_p_cuc && VCOL_HLC == (long)wp->w_virtcol)
  			ScreenAttrs[off++] = HL_ATTR(HLF_CUC);
  		    else if (draw_color_col && VCOL_HLC == *color_cols)
  			ScreenAttrs[off++] = HL_ATTR(HLF_MC);
  		    else
  			ScreenAttrs[off++] = 0;
  
  		    if (VCOL_HLC >= rightmost_vcol)
  			break;
  
  		    ++vcol;
  		}
  	    }
  #endif
  
  	    screen_line(screen_row, wp->w_wincol, col,
  				  (int)wp->w_width, HAS_RIGHTLEFT(wp->w_p_rl));
  	    row++;
  
  	    /*
  	     * Update w_cline_height and w_cline_folded if the cursor line was
  	     * updated (saves a call to plines() later).
  	     */
  	    if (wp == curwin && lnum == curwin->w_cursor.lnum)
  	    {
  		curwin->w_cline_row = startrow;
  		curwin->w_cline_height = row - startrow;
  #ifdef FEAT_FOLDING
  		curwin->w_cline_folded = FALSE;
  #endif
  		curwin->w_valid |= (VALID_CHEIGHT|VALID_CROW);
  	    }
  
  	    break;
  	}
  
  	/* line continues beyond line end */
  	if (lcs_ext
  		&& !wp->w_p_wrap
  #ifdef FEAT_DIFF
  		&& filler_todo <= 0
  #endif
  		&& (
  #ifdef FEAT_RIGHTLEFT
  		    wp->w_p_rl ? col == 0 :
  #endif
  		    col == wp->w_width - 1)
  		&& (*ptr != NUL
  		    || (wp->w_p_list && lcs_eol_one > 0)
  		    || (n_extra && (c_extra != NUL || *p_extra != NUL))))
  	{
  	    c = lcs_ext;
  	    char_attr = HL_ATTR(HLF_AT);
  #ifdef FEAT_MBYTE
  	    mb_c = c;
  	    if (enc_utf8 && utf_char2len(c) > 1)
  	    {
  		mb_utf8 = TRUE;
  		u8cc[0] = 0;
  		c = 0xc0;
  	    }
  	    else
  		mb_utf8 = FALSE;
  #endif
  	}
  
  #ifdef FEAT_SYN_HL
  	/* advance to the next 'colorcolumn' */
  	if (draw_color_col)
  	    draw_color_col = advance_color_col(VCOL_HLC, &color_cols);
  
  	/* Highlight the cursor column if 'cursorcolumn' is set.  But don't
  	 * highlight the cursor position itself.
  	 * Also highlight the 'colorcolumn' if it is different than
  	 * 'cursorcolumn' */
  	vcol_save_attr = -1;
  	if (draw_state == WL_LINE && !lnum_in_visual_area
  		&& search_attr == 0 && area_attr == 0)
  	{
  	    if (wp->w_p_cuc && VCOL_HLC == (long)wp->w_virtcol
  						 && lnum != wp->w_cursor.lnum)
  	    {
  		vcol_save_attr = char_attr;
  		char_attr = hl_combine_attr(char_attr, HL_ATTR(HLF_CUC));
  	    }
  	    else if (draw_color_col && VCOL_HLC == *color_cols)
  	    {
  		vcol_save_attr = char_attr;
  		char_attr = hl_combine_attr(char_attr, HL_ATTR(HLF_MC));
  	    }
  	}
  #endif
  
  	/*
  	 * Store character to be displayed.
  	 * Skip characters that are left of the screen for 'nowrap'.
  	 */
  	vcol_prev = vcol;
  	if (draw_state < WL_LINE || n_skip <= 0)
  	{
  	    /*
  	     * Store the character.
  	     */
  #if defined(FEAT_RIGHTLEFT) && defined(FEAT_MBYTE)
  	    if (has_mbyte && wp->w_p_rl && (*mb_char2cells)(mb_c) > 1)
  	    {
  		/* A double-wide character is: put first halve in left cell. */
  		--off;
  		--col;
  	    }
  #endif
  	    ScreenLines[off] = c;
  #ifdef FEAT_MBYTE
  	    if (enc_dbcs == DBCS_JPNU)
  	    {
  		if ((mb_c & 0xff00) == 0x8e00)
  		    ScreenLines[off] = 0x8e;
  		ScreenLines2[off] = mb_c & 0xff;
  	    }
  	    else if (enc_utf8)
  	    {
  		if (mb_utf8)
  		{
  		    int i;
  
  		    ScreenLinesUC[off] = mb_c;
  		    if ((c & 0xff) == 0)
  			ScreenLines[off] = 0x80;   /* avoid storing zero */
  		    for (i = 0; i < Screen_mco; ++i)
  		    {
  			ScreenLinesC[i][off] = u8cc[i];
  			if (u8cc[i] == 0)
  			    break;
  		    }
  		}
  		else
  		    ScreenLinesUC[off] = 0;
  	    }
  	    if (multi_attr)
  	    {
  		ScreenAttrs[off] = multi_attr;
  		multi_attr = 0;
  	    }
  	    else
  #endif
  		ScreenAttrs[off] = char_attr;
  
  #ifdef FEAT_MBYTE
  	    if (has_mbyte && (*mb_char2cells)(mb_c) > 1)
  	    {
  		/* Need to fill two screen columns. */
  		++off;
  		++col;
  		if (enc_utf8)
  		    /* UTF-8: Put a 0 in the second screen char. */
  		    ScreenLines[off] = 0;
  		else
  		    /* DBCS: Put second byte in the second screen char. */
  		    ScreenLines[off] = mb_c & 0xff;
  		if (draw_state > WL_NR
  #ifdef FEAT_DIFF
  			&& filler_todo <= 0
  #endif
  			)
  		    ++vcol;
  		/* When "tocol" is halfway a character, set it to the end of
  		 * the character, otherwise highlighting won't stop. */
  		if (tocol == vcol)
  		    ++tocol;
  #ifdef FEAT_RIGHTLEFT
  		if (wp->w_p_rl)
  		{
  		    /* now it's time to backup one cell */
  		    --off;
  		    --col;
  		}
  #endif
  	    }
  #endif
  #ifdef FEAT_RIGHTLEFT
  	    if (wp->w_p_rl)
  	    {
  		--off;
  		--col;
  	    }
  	    else
  #endif
  	    {
  		++off;
  		++col;
  	    }
  	}
  #ifdef FEAT_CONCEAL
  	else if (wp->w_p_cole > 0 && is_concealing)
  	{
  	    --n_skip;
  	    ++vcol_off;
  	    if (n_extra > 0)
  		vcol_off += n_extra;
  	    if (wp->w_p_wrap)
  	    {
  		/*
  		 * Special voodoo required if 'wrap' is on.
  		 *
  		 * Advance the column indicator to force the line
  		 * drawing to wrap early. This will make the line
  		 * take up the same screen space when parts are concealed,
  		 * so that cursor line computations aren't messed up.
  		 *
  		 * To avoid the fictitious advance of 'col' causing
  		 * trailing junk to be written out of the screen line
  		 * we are building, 'boguscols' keeps track of the number
  		 * of bad columns we have advanced.
  		 */
  		if (n_extra > 0)
  		{
  		    vcol += n_extra;
  # ifdef FEAT_RIGHTLEFT
  		    if (wp->w_p_rl)
  		    {
  			col -= n_extra;
  			boguscols -= n_extra;
  		    }
  		    else
  # endif
  		    {
  			col += n_extra;
  			boguscols += n_extra;
  		    }
  		    n_extra = 0;
  		    n_attr = 0;
  		}
  
  
  # ifdef FEAT_MBYTE
  		if (has_mbyte && (*mb_char2cells)(mb_c) > 1)
  		{
  		    /* Need to fill two screen columns. */
  #  ifdef FEAT_RIGHTLEFT
  		    if (wp->w_p_rl)
  		    {
  			--boguscols;
  			--col;
  		    }
  		    else
  #  endif
  		    {
  			++boguscols;
  			++col;
  		    }
  		}
  # endif
  
  # ifdef FEAT_RIGHTLEFT
  		if (wp->w_p_rl)
  		{
  		    --boguscols;
  		    --col;
  		}
  		else
  # endif
  		{
  		    ++boguscols;
  		    ++col;
  		}
  	    }
  	    else
  	    {
  		if (n_extra > 0)
  		{
  		    vcol += n_extra;
  		    n_extra = 0;
  		    n_attr = 0;
  		}
  	    }
  
  	}
  #endif /* FEAT_CONCEAL */
  	else
  	    --n_skip;
  
  	/* Only advance the "vcol" when after the 'number' or 'relativenumber'
  	 * column. */
  	if (draw_state > WL_NR
  #ifdef FEAT_DIFF
  		&& filler_todo <= 0
  #endif
  		)
  	    ++vcol;
  
  #ifdef FEAT_SYN_HL
  	if (vcol_save_attr >= 0)
  	    char_attr = vcol_save_attr;
  #endif
  
  	/* restore attributes after "predeces" in 'listchars' */
  	if (draw_state > WL_NR && n_attr3 > 0 && --n_attr3 == 0)
  	    char_attr = saved_attr3;
  
  	/* restore attributes after last 'listchars' or 'number' char */
  	if (n_attr > 0 && draw_state == WL_LINE && --n_attr == 0)
  	    char_attr = saved_attr2;
  
  	/*
  	 * At end of screen line and there is more to come: Display the line
  	 * so far.  If there is no more to display it is caught above.
  	 */
  	if ((
  #ifdef FEAT_RIGHTLEFT
  	    wp->w_p_rl ? (col < 0) :
  #endif
  				    (col >= wp->w_width))
  		&& (*ptr != NUL
  #ifdef FEAT_DIFF
  		    || filler_todo > 0
  #endif
  		    || (wp->w_p_list && lcs_eol != NUL && p_extra != at_end_str)
  		    || (n_extra != 0 && (c_extra != NUL || *p_extra != NUL)))
  		)
  	{
  #ifdef FEAT_CONCEAL
  	    screen_line(screen_row, wp->w_wincol, col - boguscols,
  				  (int)wp->w_width, HAS_RIGHTLEFT(wp->w_p_rl));
  	    boguscols = 0;
  #else
  	    screen_line(screen_row, wp->w_wincol, col,
  				  (int)wp->w_width, HAS_RIGHTLEFT(wp->w_p_rl));
  #endif
  	    ++row;
  	    ++screen_row;
  
  	    /* When not wrapping and finished diff lines, or when displayed
  	     * '$' and highlighting until last column, break here. */
  	    if ((!wp->w_p_wrap
  #ifdef FEAT_DIFF
  		    && filler_todo <= 0
  #endif
  		    ) || lcs_eol_one == -1)
  		break;
  
  	    /* When the window is too narrow draw all "@" lines. */
  	    if (draw_state != WL_LINE
  #ifdef FEAT_DIFF
  		    && filler_todo <= 0
  #endif
  		    )
  	    {
  		win_draw_end(wp, '@', ' ', row, wp->w_height, HLF_AT);
  		draw_vsep_win(wp, row);
  		row = endrow;
  	    }
  
  	    /* When line got too long for screen break here. */
  	    if (row == endrow)
  	    {
  		++row;
  		break;
  	    }
  
  	    if (screen_cur_row == screen_row - 1
  #ifdef FEAT_DIFF
  		     && filler_todo <= 0
  #endif
  		     && wp->w_width == Columns)
  	    {
  		/* Remember that the line wraps, used for modeless copy. */
  		LineWraps[screen_row - 1] = TRUE;
  
  		/*
  		 * Special trick to make copy/paste of wrapped lines work with
  		 * xterm/screen: write an extra character beyond the end of
  		 * the line. This will work with all terminal types
  		 * (regardless of the xn,am settings).
  		 * Only do this on a fast tty.
  		 * Only do this if the cursor is on the current line
  		 * (something has been written in it).
  		 * Don't do this for the GUI.
  		 * Don't do this for double-width characters.
  		 * Don't do this for a window not at the right screen border.
  		 */
  		if (p_tf
  #ifdef FEAT_GUI
  			 && !gui.in_use
  #endif
  #ifdef FEAT_MBYTE
  			 && !(has_mbyte
  			     && ((*mb_off2cells)(LineOffset[screen_row],
  				     LineOffset[screen_row] + screen_Columns)
  									  == 2
  				 || (*mb_off2cells)(LineOffset[screen_row - 1]
  							+ (int)Columns - 2,
  				     LineOffset[screen_row] + screen_Columns)
  									== 2))
  #endif
  		   )
  		{
  		    /* First make sure we are at the end of the screen line,
  		     * then output the same character again to let the
  		     * terminal know about the wrap.  If the terminal doesn't
  		     * auto-wrap, we overwrite the character. */
  		    if (screen_cur_col != wp->w_width)
  			screen_char(LineOffset[screen_row - 1]
  						      + (unsigned)Columns - 1,
  					  screen_row - 1, (int)(Columns - 1));
  
  #ifdef FEAT_MBYTE
  		    /* When there is a multi-byte character, just output a
  		     * space to keep it simple. */
  		    if (has_mbyte && MB_BYTE2LEN(ScreenLines[LineOffset[
  					screen_row - 1] + (Columns - 1)]) > 1)
  			out_char(' ');
  		    else
  #endif
  			out_char(ScreenLines[LineOffset[screen_row - 1]
  							    + (Columns - 1)]);
  		    /* force a redraw of the first char on the next line */
  		    ScreenAttrs[LineOffset[screen_row]] = (sattr_T)-1;
  		    screen_start();	/* don't know where cursor is now */
  		}
  	    }
  
  	    col = 0;
  	    off = (unsigned)(current_ScreenLine - ScreenLines);
  #ifdef FEAT_RIGHTLEFT
  	    if (wp->w_p_rl)
  	    {
  		col = wp->w_width - 1;	/* col is not used if breaking! */
  		off += col;
  	    }
  #endif
  
  	    /* reset the drawing state for the start of a wrapped line */
  	    draw_state = WL_START;
  	    saved_n_extra = n_extra;
  	    saved_p_extra = p_extra;
  	    saved_c_extra = c_extra;
  	    saved_char_attr = char_attr;
  	    n_extra = 0;
  	    lcs_prec_todo = lcs_prec;
  #ifdef FEAT_LINEBREAK
  # ifdef FEAT_DIFF
  	    if (filler_todo <= 0)
  # endif
  		need_showbreak = TRUE;
  #endif
  #ifdef FEAT_DIFF
  	    --filler_todo;
  	    /* When the filler lines are actually below the last line of the
  	     * file, don't draw the line itself, break here. */
  	    if (filler_todo == 0 && wp->w_botfill)
  		break;
  #endif
  	}
  
      }	/* for every character in the line */
  
  #ifdef FEAT_SPELL
      /* After an empty line check first word for capital. */
      if (*skipwhite(line) == NUL)
      {
  	capcol_lnum = lnum + 1;
  	cap_col = 0;
      }
  #endif
  
      vim_free(p_extra_free);
      return row;
  }
  
  #ifdef FEAT_MBYTE
  static int comp_char_differs(int, int);
  
  /*
   * Return if the composing characters at "off_from" and "off_to" differ.
   * Only to be used when ScreenLinesUC[off_from] != 0.
   */
      static int
  comp_char_differs(int off_from, int off_to)
  {
      int	    i;
  
      for (i = 0; i < Screen_mco; ++i)
      {
  	if (ScreenLinesC[i][off_from] != ScreenLinesC[i][off_to])
  	    return TRUE;
  	if (ScreenLinesC[i][off_from] == 0)
  	    break;
      }
      return FALSE;
  }
  #endif
  
  /*
   * Check whether the given character needs redrawing:
   * - the (first byte of the) character is different
   * - the attributes are different
   * - the character is multi-byte and the next byte is different
   * - the character is two cells wide and the second cell differs.
   */
      static int
  char_needs_redraw(int off_from, int off_to, int cols)
  {
      if (cols > 0
  	    && ((ScreenLines[off_from] != ScreenLines[off_to]
  		    || ScreenAttrs[off_from] != ScreenAttrs[off_to])
  
  #ifdef FEAT_MBYTE
  		|| (enc_dbcs != 0
  		    && MB_BYTE2LEN(ScreenLines[off_from]) > 1
  		    && (enc_dbcs == DBCS_JPNU && ScreenLines[off_from] == 0x8e
  			? ScreenLines2[off_from] != ScreenLines2[off_to]
  			: (cols > 1 && ScreenLines[off_from + 1]
  						 != ScreenLines[off_to + 1])))
  		|| (enc_utf8
  		    && (ScreenLinesUC[off_from] != ScreenLinesUC[off_to]
  			|| (ScreenLinesUC[off_from] != 0
  			    && comp_char_differs(off_from, off_to))
  			|| ((*mb_off2cells)(off_from, off_from + cols) > 1
  			    && ScreenLines[off_from + 1]
  						  != ScreenLines[off_to + 1])))
  #endif
  	       ))
  	return TRUE;
      return FALSE;
  }
  
  #if defined(FEAT_TERMINAL) || defined(PROTO)
  /*
   * Return the index in ScreenLines[] for the current screen line.
   */
      int
  screen_get_current_line_off()
  {
      return (int)(current_ScreenLine - ScreenLines);
  }
  #endif
  
  /*
   * Move one "cooked" screen line to the screen, but only the characters that
   * have actually changed.  Handle insert/delete character.
   * "coloff" gives the first column on the screen for this line.
   * "endcol" gives the columns where valid characters are.
   * "clear_width" is the width of the window.  It's > 0 if the rest of the line
   * needs to be cleared, negative otherwise.
   * "rlflag" is TRUE in a rightleft window:
   *    When TRUE and "clear_width" > 0, clear columns 0 to "endcol"
   *    When FALSE and "clear_width" > 0, clear columns "endcol" to "clear_width"
   */
      void
  screen_line(
      int	    row,
      int	    coloff,
      int	    endcol,
      int	    clear_width,
      int	    rlflag UNUSED)
  {
      unsigned	    off_from;
      unsigned	    off_to;
  #ifdef FEAT_MBYTE
      unsigned	    max_off_from;
      unsigned	    max_off_to;
  #endif
      int		    col = 0;
      int		    hl;
      int		    force = FALSE;	/* force update rest of the line */
      int		    redraw_this		/* bool: does character need redraw? */
  #ifdef FEAT_GUI
  				= TRUE	/* For GUI when while-loop empty */
  #endif
  				;
      int		    redraw_next;	/* redraw_this for next character */
  #ifdef FEAT_MBYTE
      int		    clear_next = FALSE;
      int		    char_cells;		/* 1: normal char */
  					/* 2: occupies two display cells */
  # define CHAR_CELLS char_cells
  #else
  # define CHAR_CELLS 1
  #endif
  
      /* Check for illegal row and col, just in case. */
      if (row >= Rows)
  	row = Rows - 1;
      if (endcol > Columns)
  	endcol = Columns;
  
  # ifdef FEAT_CLIPBOARD
      clip_may_clear_selection(row, row);
  # endif
  
      off_from = (unsigned)(current_ScreenLine - ScreenLines);
      off_to = LineOffset[row] + coloff;
  #ifdef FEAT_MBYTE
      max_off_from = off_from + screen_Columns;
      max_off_to = LineOffset[row] + screen_Columns;
  #endif
  
  #ifdef FEAT_RIGHTLEFT
      if (rlflag)
      {
  	/* Clear rest first, because it's left of the text. */
  	if (clear_width > 0)
  	{
  	    while (col <= endcol && ScreenLines[off_to] == ' '
  		    && ScreenAttrs[off_to] == 0
  # ifdef FEAT_MBYTE
  				  && (!enc_utf8 || ScreenLinesUC[off_to] == 0)
  # endif
  						  )
  	    {
  		++off_to;
  		++col;
  	    }
  	    if (col <= endcol)
  		screen_fill(row, row + 1, col + coloff,
  					    endcol + coloff + 1, ' ', ' ', 0);
  	}
  	col = endcol + 1;
  	off_to = LineOffset[row] + col + coloff;
  	off_from += col;
  	endcol = (clear_width > 0 ? clear_width : -clear_width);
      }
  #endif /* FEAT_RIGHTLEFT */
  
      redraw_next = char_needs_redraw(off_from, off_to, endcol - col);
  
      while (col < endcol)
      {
  #ifdef FEAT_MBYTE
  	if (has_mbyte && (col + 1 < endcol))
  	    char_cells = (*mb_off2cells)(off_from, max_off_from);
  	else
  	    char_cells = 1;
  #endif
  
  	redraw_this = redraw_next;
  	redraw_next = force || char_needs_redraw(off_from + CHAR_CELLS,
  			      off_to + CHAR_CELLS, endcol - col - CHAR_CELLS);
  
  #ifdef FEAT_GUI
  	/* If the next character was bold, then redraw the current character to
  	 * remove any pixels that might have spilt over into us.  This only
  	 * happens in the GUI.
  	 */
  	if (redraw_next && gui.in_use)
  	{
  	    hl = ScreenAttrs[off_to + CHAR_CELLS];
  	    if (hl > HL_ALL)
  		hl = syn_attr2attr(hl);
  	    if (hl & HL_BOLD)
  		redraw_this = TRUE;
  	}
  #endif
  
  	if (redraw_this)
  	{
  	    /*
  	     * Special handling when 'xs' termcap flag set (hpterm):
  	     * Attributes for characters are stored at the position where the
  	     * cursor is when writing the highlighting code.  The
  	     * start-highlighting code must be written with the cursor on the
  	     * first highlighted character.  The stop-highlighting code must
  	     * be written with the cursor just after the last highlighted
  	     * character.
  	     * Overwriting a character doesn't remove it's highlighting.  Need
  	     * to clear the rest of the line, and force redrawing it
  	     * completely.
  	     */
  	    if (       p_wiv
  		    && !force
  #ifdef FEAT_GUI
  		    && !gui.in_use
  #endif
  		    && ScreenAttrs[off_to] != 0
  		    && ScreenAttrs[off_from] != ScreenAttrs[off_to])
  	    {
  		/*
  		 * Need to remove highlighting attributes here.
  		 */
  		windgoto(row, col + coloff);
  		out_str(T_CE);		/* clear rest of this screen line */
  		screen_start();		/* don't know where cursor is now */
  		force = TRUE;		/* force redraw of rest of the line */
  		redraw_next = TRUE;	/* or else next char would miss out */
  
  		/*
  		 * If the previous character was highlighted, need to stop
  		 * highlighting at this character.
  		 */
  		if (col + coloff > 0 && ScreenAttrs[off_to - 1] != 0)
  		{
  		    screen_attr = ScreenAttrs[off_to - 1];
  		    term_windgoto(row, col + coloff);
  		    screen_stop_highlight();
  		}
  		else
  		    screen_attr = 0;	    /* highlighting has stopped */
  	    }
  #ifdef FEAT_MBYTE
  	    if (enc_dbcs != 0)
  	    {
  		/* Check if overwriting a double-byte with a single-byte or
  		 * the other way around requires another character to be
  		 * redrawn.  For UTF-8 this isn't needed, because comparing
  		 * ScreenLinesUC[] is sufficient. */
  		if (char_cells == 1
  			&& col + 1 < endcol
  			&& (*mb_off2cells)(off_to, max_off_to) > 1)
  		{
  		    /* Writing a single-cell character over a double-cell
  		     * character: need to redraw the next cell. */
  		    ScreenLines[off_to + 1] = 0;
  		    redraw_next = TRUE;
  		}
  		else if (char_cells == 2
  			&& col + 2 < endcol
  			&& (*mb_off2cells)(off_to, max_off_to) == 1
  			&& (*mb_off2cells)(off_to + 1, max_off_to) > 1)
  		{
  		    /* Writing the second half of a double-cell character over
  		     * a double-cell character: need to redraw the second
  		     * cell. */
  		    ScreenLines[off_to + 2] = 0;
  		    redraw_next = TRUE;
  		}
  
  		if (enc_dbcs == DBCS_JPNU)
  		    ScreenLines2[off_to] = ScreenLines2[off_from];
  	    }
  	    /* When writing a single-width character over a double-width
  	     * character and at the end of the redrawn text, need to clear out
  	     * the right halve of the old character.
  	     * Also required when writing the right halve of a double-width
  	     * char over the left halve of an existing one. */
  	    if (has_mbyte && col + char_cells == endcol
  		    && ((char_cells == 1
  			    && (*mb_off2cells)(off_to, max_off_to) > 1)
  			|| (char_cells == 2
  			    && (*mb_off2cells)(off_to, max_off_to) == 1
  			    && (*mb_off2cells)(off_to + 1, max_off_to) > 1)))
  		clear_next = TRUE;
  #endif
  
  	    ScreenLines[off_to] = ScreenLines[off_from];
  #ifdef FEAT_MBYTE
  	    if (enc_utf8)
  	    {
  		ScreenLinesUC[off_to] = ScreenLinesUC[off_from];
  		if (ScreenLinesUC[off_from] != 0)
  		{
  		    int	    i;
  
  		    for (i = 0; i < Screen_mco; ++i)
  			ScreenLinesC[i][off_to] = ScreenLinesC[i][off_from];
  		}
  	    }
  	    if (char_cells == 2)
  		ScreenLines[off_to + 1] = ScreenLines[off_from + 1];
  #endif
  
  #if defined(FEAT_GUI) || defined(UNIX)
  	    /* The bold trick makes a single column of pixels appear in the
  	     * next character.  When a bold character is removed, the next
  	     * character should be redrawn too.  This happens for our own GUI
  	     * and for some xterms. */
  	    if (
  # ifdef FEAT_GUI
  		    gui.in_use
  # endif
  # if defined(FEAT_GUI) && defined(UNIX)
  		    ||
  # endif
  # ifdef UNIX
  		    term_is_xterm
  # endif
  		    )
  	    {
  		hl = ScreenAttrs[off_to];
  		if (hl > HL_ALL)
  		    hl = syn_attr2attr(hl);
  		if (hl & HL_BOLD)
  		    redraw_next = TRUE;
  	    }
  #endif
  	    ScreenAttrs[off_to] = ScreenAttrs[off_from];
  #ifdef FEAT_MBYTE
  	    /* For simplicity set the attributes of second half of a
  	     * double-wide character equal to the first half. */
  	    if (char_cells == 2)
  		ScreenAttrs[off_to + 1] = ScreenAttrs[off_from];
  
  	    if (enc_dbcs != 0 && char_cells == 2)
  		screen_char_2(off_to, row, col + coloff);
  	    else
  #endif
  		screen_char(off_to, row, col + coloff);
  	}
  	else if (  p_wiv
  #ifdef FEAT_GUI
  		&& !gui.in_use
  #endif
  		&& col + coloff > 0)
  	{
  	    if (ScreenAttrs[off_to] == ScreenAttrs[off_to - 1])
  	    {
  		/*
  		 * Don't output stop-highlight when moving the cursor, it will
  		 * stop the highlighting when it should continue.
  		 */
  		screen_attr = 0;
  	    }
  	    else if (screen_attr != 0)
  		screen_stop_highlight();
  	}
  
  	off_to += CHAR_CELLS;
  	off_from += CHAR_CELLS;
  	col += CHAR_CELLS;
      }
  
  #ifdef FEAT_MBYTE
      if (clear_next)
      {
  	/* Clear the second half of a double-wide character of which the left
  	 * half was overwritten with a single-wide character. */
  	ScreenLines[off_to] = ' ';
  	if (enc_utf8)
  	    ScreenLinesUC[off_to] = 0;
  	screen_char(off_to, row, col + coloff);
      }
  #endif
  
      if (clear_width > 0
  #ifdef FEAT_RIGHTLEFT
  		    && !rlflag
  #endif
  				   )
      {
  #ifdef FEAT_GUI
  	int startCol = col;
  #endif
  
  	/* blank out the rest of the line */
  	while (col < clear_width && ScreenLines[off_to] == ' '
  						  && ScreenAttrs[off_to] == 0
  #ifdef FEAT_MBYTE
  				  && (!enc_utf8 || ScreenLinesUC[off_to] == 0)
  #endif
  						  )
  	{
  	    ++off_to;
  	    ++col;
  	}
  	if (col < clear_width)
  	{
  #ifdef FEAT_GUI
  	    /*
  	     * In the GUI, clearing the rest of the line may leave pixels
  	     * behind if the first character cleared was bold.  Some bold
  	     * fonts spill over the left.  In this case we redraw the previous
  	     * character too.  If we didn't skip any blanks above, then we
  	     * only redraw if the character wasn't already redrawn anyway.
  	     */
  	    if (gui.in_use && (col > startCol || !redraw_this))
  	    {
  		hl = ScreenAttrs[off_to];
  		if (hl > HL_ALL || (hl & HL_BOLD))
  		{
  		    int prev_cells = 1;
  # ifdef FEAT_MBYTE
  		    if (enc_utf8)
  			/* for utf-8, ScreenLines[char_offset + 1] == 0 means
  			 * that its width is 2. */
  			prev_cells = ScreenLines[off_to - 1] == 0 ? 2 : 1;
  		    else if (enc_dbcs != 0)
  		    {
  			/* find previous character by counting from first
  			 * column and get its width. */
  			unsigned off = LineOffset[row];
  			unsigned max_off = LineOffset[row] + screen_Columns;
  
  			while (off < off_to)
  			{
  			    prev_cells = (*mb_off2cells)(off, max_off);
  			    off += prev_cells;
  			}
  		    }
  
  		    if (enc_dbcs != 0 && prev_cells > 1)
  			screen_char_2(off_to - prev_cells, row,
  						   col + coloff - prev_cells);
  		    else
  # endif
  			screen_char(off_to - prev_cells, row,
  						   col + coloff - prev_cells);
  		}
  	    }
  #endif
  	    screen_fill(row, row + 1, col + coloff, clear_width + coloff,
  								 ' ', ' ', 0);
  	    off_to += clear_width - col;
  	    col = clear_width;
  	}
      }
  
      if (clear_width > 0)
      {
  	/* For a window that's left of another, draw the separator char. */
  	if (col + coloff < Columns)
  	{
  	    int c;
  
  	    c = fillchar_vsep(&hl);
  	    if (ScreenLines[off_to] != (schar_T)c
  #ifdef FEAT_MBYTE
  		    || (enc_utf8 && (int)ScreenLinesUC[off_to]
  						       != (c >= 0x80 ? c : 0))
  #endif
  		    || ScreenAttrs[off_to] != hl)
  	    {
  		ScreenLines[off_to] = c;
  		ScreenAttrs[off_to] = hl;
  #ifdef FEAT_MBYTE
  		if (enc_utf8)
  		{
  		    if (c >= 0x80)
  		    {
  			ScreenLinesUC[off_to] = c;
  			ScreenLinesC[0][off_to] = 0;
  		    }
  		    else
  			ScreenLinesUC[off_to] = 0;
  		}
  #endif
  		screen_char(off_to, row, col + coloff);
  	    }
  	}
  	else
  	    LineWraps[row] = FALSE;
      }
  }
  
  #if defined(FEAT_RIGHTLEFT) || defined(PROTO)
  /*
   * Mirror text "str" for right-left displaying.
   * Only works for single-byte characters (e.g., numbers).
   */
      void
  rl_mirror(char_u *str)
  {
      char_u	*p1, *p2;
      int		t;
  
      for (p1 = str, p2 = str + STRLEN(str) - 1; p1 < p2; ++p1, --p2)
      {
  	t = *p1;
  	*p1 = *p2;
  	*p2 = t;
      }
  }
  #endif
  
  /*
   * mark all status lines for redraw; used after first :cd
   */
      void
  status_redraw_all(void)
  {
      win_T	*wp;
  
      FOR_ALL_WINDOWS(wp)
  	if (wp->w_status_height)
  	{
  	    wp->w_redr_status = TRUE;
  	    redraw_later(VALID);
  	}
  }
  
  /*
   * mark all status lines of the current buffer for redraw
   */
      void
  status_redraw_curbuf(void)
  {
      win_T	*wp;
  
      FOR_ALL_WINDOWS(wp)
  	if (wp->w_status_height != 0 && wp->w_buffer == curbuf)
  	{
  	    wp->w_redr_status = TRUE;
  	    redraw_later(VALID);
  	}
  }
  
  /*
   * Redraw all status lines that need to be redrawn.
   */
      void
  redraw_statuslines(void)
  {
      win_T	*wp;
  
      FOR_ALL_WINDOWS(wp)
  	if (wp->w_redr_status)
  	    win_redr_status(wp);
      if (redraw_tabline)
  	draw_tabline();
  }
  
  #if defined(FEAT_WILDMENU) || defined(PROTO)
  /*
   * Redraw all status lines at the bottom of frame "frp".
   */
      void
  win_redraw_last_status(frame_T *frp)
  {
      if (frp->fr_layout == FR_LEAF)
  	frp->fr_win->w_redr_status = TRUE;
      else if (frp->fr_layout == FR_ROW)
      {
  	for (frp = frp->fr_child; frp != NULL; frp = frp->fr_next)
  	    win_redraw_last_status(frp);
      }
      else /* frp->fr_layout == FR_COL */
      {
  	frp = frp->fr_child;
  	while (frp->fr_next != NULL)
  	    frp = frp->fr_next;
  	win_redraw_last_status(frp);
      }
  }
  #endif
  
  /*
   * Draw the verticap separator right of window "wp" starting with line "row".
   */
      static void
  draw_vsep_win(win_T *wp, int row)
  {
      int		hl;
      int		c;
  
      if (wp->w_vsep_width)
      {
  	/* draw the vertical separator right of this window */
  	c = fillchar_vsep(&hl);
  	screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + wp->w_height,
  		W_ENDCOL(wp), W_ENDCOL(wp) + 1,
  		c, ' ', hl);
      }
  }
  
  #ifdef FEAT_WILDMENU
  static int status_match_len(expand_T *xp, char_u *s);
  static int skip_status_match_char(expand_T *xp, char_u *s);
  
  /*
   * Get the length of an item as it will be shown in the status line.
   */
      static int
  status_match_len(expand_T *xp, char_u *s)
  {
      int	len = 0;
  
  #ifdef FEAT_MENU
      int emenu = (xp->xp_context == EXPAND_MENUS
  	    || xp->xp_context == EXPAND_MENUNAMES);
  
      /* Check for menu separators - replace with '|'. */
      if (emenu && menu_is_separator(s))
  	return 1;
  #endif
  
      while (*s != NUL)
      {
  	s += skip_status_match_char(xp, s);
  	len += ptr2cells(s);
  	MB_PTR_ADV(s);
      }
  
      return len;
  }
  
  /*
   * Return the number of characters that should be skipped in a status match.
   * These are backslashes used for escaping.  Do show backslashes in help tags.
   */
      static int
  skip_status_match_char(expand_T *xp, char_u *s)
  {
      if ((rem_backslash(s) && xp->xp_context != EXPAND_HELP)
  #ifdef FEAT_MENU
  	    || ((xp->xp_context == EXPAND_MENUS
  		    || xp->xp_context == EXPAND_MENUNAMES)
  			  && (s[0] == '\t' || (s[0] == '\\' && s[1] != NUL)))
  #endif
  	   )
      {
  #ifndef BACKSLASH_IN_FILENAME
  	if (xp->xp_shell && csh_like_shell() && s[1] == '\\' && s[2] == '!')
  	    return 2;
  #endif
  	return 1;
      }
      return 0;
  }
  
  /*
   * Show wildchar matches in the status line.
   * Show at least the "match" item.
   * We start at item 'first_match' in the list and show all matches that fit.
   *
   * If inversion is possible we use it. Else '=' characters are used.
   */
      void
  win_redr_status_matches(
      expand_T	*xp,
      int		num_matches,
      char_u	**matches,	/* list of matches */
      int		match,
      int		showtail)
  {
  #define L_MATCH(m) (showtail ? sm_gettail(matches[m]) : matches[m])
      int		row;
      char_u	*buf;
      int		len;
      int		clen;		/* length in screen cells */
      int		fillchar;
      int		attr;
      int		i;
      int		highlight = TRUE;
      char_u	*selstart = NULL;
      int		selstart_col = 0;
      char_u	*selend = NULL;
      static int	first_match = 0;
      int		add_left = FALSE;
      char_u	*s;
  #ifdef FEAT_MENU
      int		emenu;
  #endif
  #if defined(FEAT_MBYTE) || defined(FEAT_MENU)
      int		l;
  #endif
  
      if (matches == NULL)	/* interrupted completion? */
  	return;
  
  #ifdef FEAT_MBYTE
      if (has_mbyte)
  	buf = alloc((unsigned)Columns * MB_MAXBYTES + 1);
      else
  #endif
  	buf = alloc((unsigned)Columns + 1);
      if (buf == NULL)
  	return;
  
      if (match == -1)	/* don't show match but original text */
      {
  	match = 0;
  	highlight = FALSE;
      }
      /* count 1 for the ending ">" */
      clen = status_match_len(xp, L_MATCH(match)) + 3;
      if (match == 0)
  	first_match = 0;
      else if (match < first_match)
      {
  	/* jumping left, as far as we can go */
  	first_match = match;
  	add_left = TRUE;
      }
      else
      {
  	/* check if match fits on the screen */
  	for (i = first_match; i < match; ++i)
  	    clen += status_match_len(xp, L_MATCH(i)) + 2;
  	if (first_match > 0)
  	    clen += 2;
  	/* jumping right, put match at the left */
  	if ((long)clen > Columns)
  	{
  	    first_match = match;
  	    /* if showing the last match, we can add some on the left */
  	    clen = 2;
  	    for (i = match; i < num_matches; ++i)
  	    {
  		clen += status_match_len(xp, L_MATCH(i)) + 2;
  		if ((long)clen >= Columns)
  		    break;
  	    }
  	    if (i == num_matches)
  		add_left = TRUE;
  	}
      }
      if (add_left)
  	while (first_match > 0)
  	{
  	    clen += status_match_len(xp, L_MATCH(first_match - 1)) + 2;
  	    if ((long)clen >= Columns)
  		break;
  	    --first_match;
  	}
  
      fillchar = fillchar_status(&attr, curwin);
  
      if (first_match == 0)
      {
  	*buf = NUL;
  	len = 0;
      }
      else
      {
  	STRCPY(buf, "< ");
  	len = 2;
      }
      clen = len;
  
      i = first_match;
      while ((long)(clen + status_match_len(xp, L_MATCH(i)) + 2) < Columns)
      {
  	if (i == match)
  	{
  	    selstart = buf + len;
  	    selstart_col = clen;
  	}
  
  	s = L_MATCH(i);
  	/* Check for menu separators - replace with '|' */
  #ifdef FEAT_MENU
  	emenu = (xp->xp_context == EXPAND_MENUS
  		|| xp->xp_context == EXPAND_MENUNAMES);
  	if (emenu && menu_is_separator(s))
  	{
  	    STRCPY(buf + len, transchar('|'));
  	    l = (int)STRLEN(buf + len);
  	    len += l;
  	    clen += l;
  	}
  	else
  #endif
  	    for ( ; *s != NUL; ++s)
  	{
  	    s += skip_status_match_char(xp, s);
  	    clen += ptr2cells(s);
  #ifdef FEAT_MBYTE
  	    if (has_mbyte && (l = (*mb_ptr2len)(s)) > 1)
  	    {
  		STRNCPY(buf + len, s, l);
  		s += l - 1;
  		len += l;
  	    }
  	    else
  #endif
  	    {
  		STRCPY(buf + len, transchar_byte(*s));
  		len += (int)STRLEN(buf + len);
  	    }
  	}
  	if (i == match)
  	    selend = buf + len;
  
  	*(buf + len++) = ' ';
  	*(buf + len++) = ' ';
  	clen += 2;
  	if (++i == num_matches)
  		break;
      }
  
      if (i != num_matches)
      {
  	*(buf + len++) = '>';
  	++clen;
      }
  
      buf[len] = NUL;
  
      row = cmdline_row - 1;
      if (row >= 0)
      {
  	if (wild_menu_showing == 0)
  	{
  	    if (msg_scrolled > 0)
  	    {
  		/* Put the wildmenu just above the command line.  If there is
  		 * no room, scroll the screen one line up. */
  		if (cmdline_row == Rows - 1)
  		{
  		    screen_del_lines(0, 0, 1, (int)Rows, TRUE, 0, NULL);
  		    ++msg_scrolled;
  		}
  		else
  		{
  		    ++cmdline_row;
  		    ++row;
  		}
  		wild_menu_showing = WM_SCROLLED;
  	    }
  	    else
  	    {
  		/* Create status line if needed by setting 'laststatus' to 2.
  		 * Set 'winminheight' to zero to avoid that the window is
  		 * resized. */
  		if (lastwin->w_status_height == 0)
  		{
  		    save_p_ls = p_ls;
  		    save_p_wmh = p_wmh;
  		    p_ls = 2;
  		    p_wmh = 0;
  		    last_status(FALSE);
  		}
  		wild_menu_showing = WM_SHOWN;
  	    }
  	}
  
  	screen_puts(buf, row, 0, attr);
  	if (selstart != NULL && highlight)
  	{
  	    *selend = NUL;
  	    screen_puts(selstart, row, selstart_col, HL_ATTR(HLF_WM));
  	}
  
  	screen_fill(row, row + 1, clen, (int)Columns, fillchar, fillchar, attr);
      }
  
      win_redraw_last_status(topframe);
      vim_free(buf);
  }
  #endif
  
  /*
   * Redraw the status line of window wp.
   *
   * If inversion is possible we use it. Else '=' characters are used.
   */
      void
  win_redr_status(win_T *wp)
  {
      int		row;
      char_u	*p;
      int		len;
      int		fillchar;
      int		attr;
      int		this_ru_col;
      static int  busy = FALSE;
  
      /* It's possible to get here recursively when 'statusline' (indirectly)
       * invokes ":redrawstatus".  Simply ignore the call then. */
      if (busy)
  	return;
      busy = TRUE;
  
      wp->w_redr_status = FALSE;
      if (wp->w_status_height == 0)
      {
  	/* no status line, can only be last window */
  	redraw_cmdline = TRUE;
      }
      else if (!redrawing()
  #ifdef FEAT_INS_EXPAND
  	    /* don't update status line when popup menu is visible and may be
  	     * drawn over it */
  	    || pum_visible()
  #endif
  	    )
      {
  	/* Don't redraw right now, do it later. */
  	wp->w_redr_status = TRUE;
      }
  #ifdef FEAT_STL_OPT
      else if (*p_stl != NUL || *wp->w_p_stl != NUL)
      {
  	/* redraw custom status line */
  	redraw_custom_statusline(wp);
      }
  #endif
      else
      {
  	fillchar = fillchar_status(&attr, wp);
  
  	get_trans_bufname(wp->w_buffer);
  	p = NameBuff;
  	len = (int)STRLEN(p);
  
  	if (bt_help(wp->w_buffer)
  #ifdef FEAT_QUICKFIX
  		|| wp->w_p_pvw
  #endif
  		|| bufIsChanged(wp->w_buffer)
  		|| wp->w_buffer->b_p_ro)
  	    *(p + len++) = ' ';
  	if (bt_help(wp->w_buffer))
  	{
  	    STRCPY(p + len, _("[Help]"));
  	    len += (int)STRLEN(p + len);
  	}
  #ifdef FEAT_QUICKFIX
  	if (wp->w_p_pvw)
  	{
  	    STRCPY(p + len, _("[Preview]"));
  	    len += (int)STRLEN(p + len);
  	}
  #endif
  	if (bufIsChanged(wp->w_buffer)
  #ifdef FEAT_TERMINAL
  		&& !bt_terminal(wp->w_buffer)
  #endif
  		)
  	{
  	    STRCPY(p + len, "[+]");
  	    len += 3;
  	}
  	if (wp->w_buffer->b_p_ro)
  	{
  	    STRCPY(p + len, _("[RO]"));
  	    len += (int)STRLEN(p + len);
  	}
  
  	this_ru_col = ru_col - (Columns - wp->w_width);
  	if (this_ru_col < (wp->w_width + 1) / 2)
  	    this_ru_col = (wp->w_width + 1) / 2;
  	if (this_ru_col <= 1)
  	{
  	    p = (char_u *)"<";		/* No room for file name! */
  	    len = 1;
  	}
  	else
  #ifdef FEAT_MBYTE
  	    if (has_mbyte)
  	    {
  		int	clen = 0, i;
  
  		/* Count total number of display cells. */
  		clen = mb_string2cells(p, -1);
  
  		/* Find first character that will fit.
  		 * Going from start to end is much faster for DBCS. */
  		for (i = 0; p[i] != NUL && clen >= this_ru_col - 1;
  					      i += (*mb_ptr2len)(p + i))
  		    clen -= (*mb_ptr2cells)(p + i);
  		len = clen;
  		if (i > 0)
  		{
  		    p = p + i - 1;
  		    *p = '<';
  		    ++len;
  		}
  
  	    }
  	    else
  #endif
  	    if (len > this_ru_col - 1)
  	    {
  		p += len - (this_ru_col - 1);
  		*p = '<';
  		len = this_ru_col - 1;
  	    }
  
  	row = W_WINROW(wp) + wp->w_height;
  	screen_puts(p, row, wp->w_wincol, attr);
  	screen_fill(row, row + 1, len + wp->w_wincol,
  			this_ru_col + wp->w_wincol, fillchar, fillchar, attr);
  
  	if (get_keymap_str(wp, (char_u *)"<%s>", NameBuff, MAXPATHL)
  		&& (int)(this_ru_col - len) > (int)(STRLEN(NameBuff) + 1))
  	    screen_puts(NameBuff, row, (int)(this_ru_col - STRLEN(NameBuff)
  						   - 1 + wp->w_wincol), attr);
  
  #ifdef FEAT_CMDL_INFO
  	win_redr_ruler(wp, TRUE);
  #endif
      }
  
      /*
       * May need to draw the character below the vertical separator.
       */
      if (wp->w_vsep_width != 0 && wp->w_status_height != 0 && redrawing())
      {
  	if (stl_connected(wp))
  	    fillchar = fillchar_status(&attr, wp);
  	else
  	    fillchar = fillchar_vsep(&attr);
  	screen_putchar(fillchar, W_WINROW(wp) + wp->w_height, W_ENDCOL(wp),
  									attr);
      }
      busy = FALSE;
  }
  
  #ifdef FEAT_STL_OPT
  /*
   * Redraw the status line according to 'statusline' and take care of any
   * errors encountered.
   */
      static void
  redraw_custom_statusline(win_T *wp)
  {
      static int	    entered = FALSE;
      int		    saved_did_emsg = did_emsg;
  
      /* When called recursively return.  This can happen when the statusline
       * contains an expression that triggers a redraw. */
      if (entered)
  	return;
      entered = TRUE;
  
      did_emsg = FALSE;
      win_redr_custom(wp, FALSE);
      if (did_emsg)
      {
  	/* When there is an error disable the statusline, otherwise the
  	 * display is messed up with errors and a redraw triggers the problem
  	 * again and again. */
  	set_string_option_direct((char_u *)"statusline", -1,
  		(char_u *)"", OPT_FREE | (*wp->w_p_stl != NUL
  					? OPT_LOCAL : OPT_GLOBAL), SID_ERROR);
      }
      did_emsg |= saved_did_emsg;
      entered = FALSE;
  }
  #endif
  
  /*
   * Return TRUE if the status line of window "wp" is connected to the status
   * line of the window right of it.  If not, then it's a vertical separator.
   * Only call if (wp->w_vsep_width != 0).
   */
      int
  stl_connected(win_T *wp)
  {
      frame_T	*fr;
  
      fr = wp->w_frame;
      while (fr->fr_parent != NULL)
      {
  	if (fr->fr_parent->fr_layout == FR_COL)
  	{
  	    if (fr->fr_next != NULL)
  		break;
  	}
  	else
  	{
  	    if (fr->fr_next != NULL)
  		return TRUE;
  	}
  	fr = fr->fr_parent;
      }
      return FALSE;
  }
  
  
  /*
   * Get the value to show for the language mappings, active 'keymap'.
   */
      int
  get_keymap_str(
      win_T	*wp,
      char_u	*fmt,	    /* format string containing one %s item */
      char_u	*buf,	    /* buffer for the result */
      int		len)	    /* length of buffer */
  {
      char_u	*p;
  
      if (wp->w_buffer->b_p_iminsert != B_IMODE_LMAP)
  	return FALSE;
  
      {
  #ifdef FEAT_EVAL
  	buf_T	*old_curbuf = curbuf;
  	win_T	*old_curwin = curwin;
  	char_u	*s;
  
  	curbuf = wp->w_buffer;
  	curwin = wp;
  	STRCPY(buf, "b:keymap_name");	/* must be writable */
  	++emsg_skip;
  	s = p = eval_to_string(buf, NULL, FALSE);
  	--emsg_skip;
  	curbuf = old_curbuf;
  	curwin = old_curwin;
  	if (p == NULL || *p == NUL)
  #endif
  	{
  #ifdef FEAT_KEYMAP
  	    if (wp->w_buffer->b_kmap_state & KEYMAP_LOADED)
  		p = wp->w_buffer->b_p_keymap;
  	    else
  #endif
  		p = (char_u *)"lang";
  	}
  	if (vim_snprintf((char *)buf, len, (char *)fmt, p) > len - 1)
  	    buf[0] = NUL;
  #ifdef FEAT_EVAL
  	vim_free(s);
  #endif
      }
      return buf[0] != NUL;
  }
  
  #if defined(FEAT_STL_OPT) || defined(PROTO)
  /*
   * Redraw the status line or ruler of window "wp".
   * When "wp" is NULL redraw the tab pages line from 'tabline'.
   */
      static void
  win_redr_custom(
      win_T	*wp,
      int		draw_ruler)	/* TRUE or FALSE */
  {
      static int	entered = FALSE;
      int		attr;
      int		curattr;
      int		row;
      int		col = 0;
      int		maxwidth;
      int		width;
      int		n;
      int		len;
      int		fillchar;
      char_u	buf[MAXPATHL];
      char_u	*stl;
      char_u	*p;
      struct	stl_hlrec hltab[STL_MAX_ITEM];
      struct	stl_hlrec tabtab[STL_MAX_ITEM];
      int		use_sandbox = FALSE;
      win_T	*ewp;
      int		p_crb_save;
  
      /* There is a tiny chance that this gets called recursively: When
       * redrawing a status line triggers redrawing the ruler or tabline.
       * Avoid trouble by not allowing recursion. */
      if (entered)
  	return;
      entered = TRUE;
  
      /* setup environment for the task at hand */
      if (wp == NULL)
      {
  	/* Use 'tabline'.  Always at the first line of the screen. */
  	stl = p_tal;
  	row = 0;
  	fillchar = ' ';
  	attr = HL_ATTR(HLF_TPF);
  	maxwidth = Columns;
  # ifdef FEAT_EVAL
  	use_sandbox = was_set_insecurely((char_u *)"tabline", 0);
  # endif
      }
      else
      {
  	row = W_WINROW(wp) + wp->w_height;
  	fillchar = fillchar_status(&attr, wp);
  	maxwidth = wp->w_width;
  
  	if (draw_ruler)
  	{
  	    stl = p_ruf;
  	    /* advance past any leading group spec - implicit in ru_col */
  	    if (*stl == '%')
  	    {
  		if (*++stl == '-')
  		    stl++;
  		if (atoi((char *)stl))
  		    while (VIM_ISDIGIT(*stl))
  			stl++;
  		if (*stl++ != '(')
  		    stl = p_ruf;
  	    }
  	    col = ru_col - (Columns - wp->w_width);
  	    if (col < (wp->w_width + 1) / 2)
  		col = (wp->w_width + 1) / 2;
  	    maxwidth = wp->w_width - col;
  	    if (!wp->w_status_height)
  	    {
  		row = Rows - 1;
  		--maxwidth;	/* writing in last column may cause scrolling */
  		fillchar = ' ';
  		attr = 0;
  	    }
  
  # ifdef FEAT_EVAL
  	    use_sandbox = was_set_insecurely((char_u *)"rulerformat", 0);
  # endif
  	}
  	else
  	{
  	    if (*wp->w_p_stl != NUL)
  		stl = wp->w_p_stl;
  	    else
  		stl = p_stl;
  # ifdef FEAT_EVAL
  	    use_sandbox = was_set_insecurely((char_u *)"statusline",
  					 *wp->w_p_stl == NUL ? 0 : OPT_LOCAL);
  # endif
  	}
  
  	col += wp->w_wincol;
      }
  
      if (maxwidth <= 0)
  	goto theend;
  
      /* Temporarily reset 'cursorbind', we don't want a side effect from moving
       * the cursor away and back. */
      ewp = wp == NULL ? curwin : wp;
      p_crb_save = ewp->w_p_crb;
      ewp->w_p_crb = FALSE;
  
      /* Make a copy, because the statusline may include a function call that
       * might change the option value and free the memory. */
      stl = vim_strsave(stl);
      width = build_stl_str_hl(ewp, buf, sizeof(buf),
  				stl, use_sandbox,
  				fillchar, maxwidth, hltab, tabtab);
      vim_free(stl);
      ewp->w_p_crb = p_crb_save;
  
      /* Make all characters printable. */
      p = transstr(buf);
      if (p != NULL)
      {
  	vim_strncpy(buf, p, sizeof(buf) - 1);
  	vim_free(p);
      }
  
      /* fill up with "fillchar" */
      len = (int)STRLEN(buf);
      while (width < maxwidth && len < (int)sizeof(buf) - 1)
      {
  #ifdef FEAT_MBYTE
  	len += (*mb_char2bytes)(fillchar, buf + len);
  #else
  	buf[len++] = fillchar;
  #endif
  	++width;
      }
      buf[len] = NUL;
  
      /*
       * Draw each snippet with the specified highlighting.
       */
      curattr = attr;
      p = buf;
      for (n = 0; hltab[n].start != NULL; n++)
      {
  	len = (int)(hltab[n].start - p);
  	screen_puts_len(p, len, row, col, curattr);
  	col += vim_strnsize(p, len);
  	p = hltab[n].start;
  
  	if (hltab[n].userhl == 0)
  	    curattr = attr;
  	else if (hltab[n].userhl < 0)
  	    curattr = syn_id2attr(-hltab[n].userhl);
  #ifdef FEAT_TERMINAL
  	else if (wp != NULL && wp != curwin && bt_terminal(wp->w_buffer)
  						   && wp->w_status_height != 0)
  	    curattr = highlight_stltermnc[hltab[n].userhl - 1];
  	else if (wp != NULL && bt_terminal(wp->w_buffer)
  						   && wp->w_status_height != 0)
  	    curattr = highlight_stlterm[hltab[n].userhl - 1];
  #endif
  	else if (wp != NULL && wp != curwin && wp->w_status_height != 0)
  	    curattr = highlight_stlnc[hltab[n].userhl - 1];
  	else
  	    curattr = highlight_user[hltab[n].userhl - 1];
      }
      screen_puts(p, row, col, curattr);
  
      if (wp == NULL)
      {
  	/* Fill the TabPageIdxs[] array for clicking in the tab pagesline. */
  	col = 0;
  	len = 0;
  	p = buf;
  	fillchar = 0;
  	for (n = 0; tabtab[n].start != NULL; n++)
  	{
  	    len += vim_strnsize(p, (int)(tabtab[n].start - p));
  	    while (col < len)
  		TabPageIdxs[col++] = fillchar;
  	    p = tabtab[n].start;
  	    fillchar = tabtab[n].userhl;
  	}
  	while (col < Columns)
  	    TabPageIdxs[col++] = fillchar;
      }
  
  theend:
      entered = FALSE;
  }
  
  #endif /* FEAT_STL_OPT */
  
  /*
   * Output a single character directly to the screen and update ScreenLines.
   */
      void
  screen_putchar(int c, int row, int col, int attr)
  {
      char_u	buf[MB_MAXBYTES + 1];
  
  #ifdef FEAT_MBYTE
      if (has_mbyte)
  	buf[(*mb_char2bytes)(c, buf)] = NUL;
      else
  #endif
      {
  	buf[0] = c;
  	buf[1] = NUL;
      }
      screen_puts(buf, row, col, attr);
  }
  
  /*
   * Get a single character directly from ScreenLines into "bytes[]".
   * Also return its attribute in *attrp;
   */
      void
  screen_getbytes(int row, int col, char_u *bytes, int *attrp)
  {
      unsigned off;
  
      /* safety check */
      if (ScreenLines != NULL && row < screen_Rows && col < screen_Columns)
      {
  	off = LineOffset[row] + col;
  	*attrp = ScreenAttrs[off];
  	bytes[0] = ScreenLines[off];
  	bytes[1] = NUL;
  
  #ifdef FEAT_MBYTE
  	if (enc_utf8 && ScreenLinesUC[off] != 0)
  	    bytes[utfc_char2bytes(off, bytes)] = NUL;
  	else if (enc_dbcs == DBCS_JPNU && ScreenLines[off] == 0x8e)
  	{
  	    bytes[0] = ScreenLines[off];
  	    bytes[1] = ScreenLines2[off];
  	    bytes[2] = NUL;
  	}
  	else if (enc_dbcs && MB_BYTE2LEN(bytes[0]) > 1)
  	{
  	    bytes[1] = ScreenLines[off + 1];
  	    bytes[2] = NUL;
  	}
  #endif
      }
  }
  
  #ifdef FEAT_MBYTE
  static int screen_comp_differs(int, int*);
  
  /*
   * Return TRUE if composing characters for screen posn "off" differs from
   * composing characters in "u8cc".
   * Only to be used when ScreenLinesUC[off] != 0.
   */
      static int
  screen_comp_differs(int off, int *u8cc)
  {
      int	    i;
  
      for (i = 0; i < Screen_mco; ++i)
      {
  	if (ScreenLinesC[i][off] != (u8char_T)u8cc[i])
  	    return TRUE;
  	if (u8cc[i] == 0)
  	    break;
      }
      return FALSE;
  }
  #endif
  
  /*
   * Put string '*text' on the screen at position 'row' and 'col', with
   * attributes 'attr', and update ScreenLines[] and ScreenAttrs[].
   * Note: only outputs within one row, message is truncated at screen boundary!
   * Note: if ScreenLines[], row and/or col is invalid, nothing is done.
   */
      void
  screen_puts(
      char_u	*text,
      int		row,
      int		col,
      int		attr)
  {
      screen_puts_len(text, -1, row, col, attr);
  }
  
  /*
   * Like screen_puts(), but output "text[len]".  When "len" is -1 output up to
   * a NUL.
   */
      void
  screen_puts_len(
      char_u	*text,
      int		textlen,
      int		row,
      int		col,
      int		attr)
  {
      unsigned	off;
      char_u	*ptr = text;
      int		len = textlen;
      int		c;
  #ifdef FEAT_MBYTE
      unsigned	max_off;
      int		mbyte_blen = 1;
      int		mbyte_cells = 1;
      int		u8c = 0;
      int		u8cc[MAX_MCO];
      int		clear_next_cell = FALSE;
  # ifdef FEAT_ARABIC
      int		prev_c = 0;		/* previous Arabic character */
      int		pc, nc, nc1;
      int		pcc[MAX_MCO];
  # endif
  #endif
  #if defined(FEAT_MBYTE) || defined(FEAT_GUI) || defined(UNIX)
      int		force_redraw_this;
      int		force_redraw_next = FALSE;
  #endif
      int		need_redraw;
  
      if (ScreenLines == NULL || row >= screen_Rows)	/* safety check */
  	return;
      off = LineOffset[row] + col;
  
  #ifdef FEAT_MBYTE
      /* When drawing over the right halve of a double-wide char clear out the
       * left halve.  Only needed in a terminal. */
      if (has_mbyte && col > 0 && col < screen_Columns
  # ifdef FEAT_GUI
  	    && !gui.in_use
  # endif
  	    && mb_fix_col(col, row) != col)
      {
  	ScreenLines[off - 1] = ' ';
  	ScreenAttrs[off - 1] = 0;
  	if (enc_utf8)
  	{
  	    ScreenLinesUC[off - 1] = 0;
  	    ScreenLinesC[0][off - 1] = 0;
  	}
  	/* redraw the previous cell, make it empty */
  	screen_char(off - 1, row, col - 1);
  	/* force the cell at "col" to be redrawn */
  	force_redraw_next = TRUE;
      }
  #endif
  
  #ifdef FEAT_MBYTE
      max_off = LineOffset[row] + screen_Columns;
  #endif
      while (col < screen_Columns
  	    && (len < 0 || (int)(ptr - text) < len)
  	    && *ptr != NUL)
      {
  	c = *ptr;
  #ifdef FEAT_MBYTE
  	/* check if this is the first byte of a multibyte */
  	if (has_mbyte)
  	{
  	    if (enc_utf8 && len > 0)
  		mbyte_blen = utfc_ptr2len_len(ptr, (int)((text + len) - ptr));
  	    else
  		mbyte_blen = (*mb_ptr2len)(ptr);
  	    if (enc_dbcs == DBCS_JPNU && c == 0x8e)
  		mbyte_cells = 1;
  	    else if (enc_dbcs != 0)
  		mbyte_cells = mbyte_blen;
  	    else	/* enc_utf8 */
  	    {
  		if (len >= 0)
  		    u8c = utfc_ptr2char_len(ptr, u8cc,
  						   (int)((text + len) - ptr));
  		else
  		    u8c = utfc_ptr2char(ptr, u8cc);
  		mbyte_cells = utf_char2cells(u8c);
  # ifdef UNICODE16
  		/* Non-BMP character: display as ? or fullwidth ?. */
  		if (u8c >= 0x10000)
  		{
  		    u8c = (mbyte_cells == 2) ? 0xff1f : (int)'?';
  		    if (attr == 0)
  			attr = HL_ATTR(HLF_8);
  		}
  # endif
  # ifdef FEAT_ARABIC
  		if (p_arshape && !p_tbidi && ARABIC_CHAR(u8c))
  		{
  		    /* Do Arabic shaping. */
  		    if (len >= 0 && (int)(ptr - text) + mbyte_blen >= len)
  		    {
  			/* Past end of string to be displayed. */
  			nc = NUL;
  			nc1 = NUL;
  		    }
  		    else
  		    {
  			nc = utfc_ptr2char_len(ptr + mbyte_blen, pcc,
  				      (int)((text + len) - ptr - mbyte_blen));
  			nc1 = pcc[0];
  		    }
  		    pc = prev_c;
  		    prev_c = u8c;
  		    u8c = arabic_shape(u8c, &c, &u8cc[0], nc, nc1, pc);
  		}
  		else
  		    prev_c = u8c;
  # endif
  		if (col + mbyte_cells > screen_Columns)
  		{
  		    /* Only 1 cell left, but character requires 2 cells:
  		     * display a '>' in the last column to avoid wrapping. */
  		    c = '>';
  		    mbyte_cells = 1;
  		}
  	    }
  	}
  #endif
  
  #if defined(FEAT_MBYTE) || defined(FEAT_GUI) || defined(UNIX)
  	force_redraw_this = force_redraw_next;
  	force_redraw_next = FALSE;
  #endif
  
  	need_redraw = ScreenLines[off] != c
  #ifdef FEAT_MBYTE
  		|| (mbyte_cells == 2
  		    && ScreenLines[off + 1] != (enc_dbcs ? ptr[1] : 0))
  		|| (enc_dbcs == DBCS_JPNU
  		    && c == 0x8e
  		    && ScreenLines2[off] != ptr[1])
  		|| (enc_utf8
  		    && (ScreenLinesUC[off] !=
  				(u8char_T)(c < 0x80 && u8cc[0] == 0 ? 0 : u8c)
  			|| (ScreenLinesUC[off] != 0
  					  && screen_comp_differs(off, u8cc))))
  #endif
  		|| ScreenAttrs[off] != attr
  		|| exmode_active;
  
  	if (need_redraw
  #if defined(FEAT_MBYTE) || defined(FEAT_GUI) || defined(UNIX)
  		|| force_redraw_this
  #endif
  		)
  	{
  #if defined(FEAT_GUI) || defined(UNIX)
  	    /* The bold trick makes a single row of pixels appear in the next
  	     * character.  When a bold character is removed, the next
  	     * character should be redrawn too.  This happens for our own GUI
  	     * and for some xterms. */
  	    if (need_redraw && ScreenLines[off] != ' ' && (
  # ifdef FEAT_GUI
  		    gui.in_use
  # endif
  # if defined(FEAT_GUI) && defined(UNIX)
  		    ||
  # endif
  # ifdef UNIX
  		    term_is_xterm
  # endif
  		    ))
  	    {
  		int	n = ScreenAttrs[off];
  
  		if (n > HL_ALL)
  		    n = syn_attr2attr(n);
  		if (n & HL_BOLD)
  		    force_redraw_next = TRUE;
  	    }
  #endif
  #ifdef FEAT_MBYTE
  	    /* When at the end of the text and overwriting a two-cell
  	     * character with a one-cell character, need to clear the next
  	     * cell.  Also when overwriting the left halve of a two-cell char
  	     * with the right halve of a two-cell char.  Do this only once
  	     * (mb_off2cells() may return 2 on the right halve). */
  	    if (clear_next_cell)
  		clear_next_cell = FALSE;
  	    else if (has_mbyte
  		    && (len < 0 ? ptr[mbyte_blen] == NUL
  					     : ptr + mbyte_blen >= text + len)
  		    && ((mbyte_cells == 1 && (*mb_off2cells)(off, max_off) > 1)
  			|| (mbyte_cells == 2
  			    && (*mb_off2cells)(off, max_off) == 1
  			    && (*mb_off2cells)(off + 1, max_off) > 1)))
  		clear_next_cell = TRUE;
  
  	    /* Make sure we never leave a second byte of a double-byte behind,
  	     * it confuses mb_off2cells(). */
  	    if (enc_dbcs
  		    && ((mbyte_cells == 1 && (*mb_off2cells)(off, max_off) > 1)
  			|| (mbyte_cells == 2
  			    && (*mb_off2cells)(off, max_off) == 1
  			    && (*mb_off2cells)(off + 1, max_off) > 1)))
  		ScreenLines[off + mbyte_blen] = 0;
  #endif
  	    ScreenLines[off] = c;
  	    ScreenAttrs[off] = attr;
  #ifdef FEAT_MBYTE
  	    if (enc_utf8)
  	    {
  		if (c < 0x80 && u8cc[0] == 0)
  		    ScreenLinesUC[off] = 0;
  		else
  		{
  		    int	    i;
  
  		    ScreenLinesUC[off] = u8c;
  		    for (i = 0; i < Screen_mco; ++i)
  		    {
  			ScreenLinesC[i][off] = u8cc[i];
  			if (u8cc[i] == 0)
  			    break;
  		    }
  		}
  		if (mbyte_cells == 2)
  		{
  		    ScreenLines[off + 1] = 0;
  		    ScreenAttrs[off + 1] = attr;
  		}
  		screen_char(off, row, col);
  	    }
  	    else if (mbyte_cells == 2)
  	    {
  		ScreenLines[off + 1] = ptr[1];
  		ScreenAttrs[off + 1] = attr;
  		screen_char_2(off, row, col);
  	    }
  	    else if (enc_dbcs == DBCS_JPNU && c == 0x8e)
  	    {
  		ScreenLines2[off] = ptr[1];
  		screen_char(off, row, col);
  	    }
  	    else
  #endif
  		screen_char(off, row, col);
  	}
  #ifdef FEAT_MBYTE
  	if (has_mbyte)
  	{
  	    off += mbyte_cells;
  	    col += mbyte_cells;
  	    ptr += mbyte_blen;
  	    if (clear_next_cell)
  	    {
  		/* This only happens at the end, display one space next. */
  		ptr = (char_u *)" ";
  		len = -1;
  	    }
  	}
  	else
  #endif
  	{
  	    ++off;
  	    ++col;
  	    ++ptr;
  	}
      }
  
  #if defined(FEAT_MBYTE) || defined(FEAT_GUI) || defined(UNIX)
      /* If we detected the next character needs to be redrawn, but the text
       * doesn't extend up to there, update the character here. */
      if (force_redraw_next && col < screen_Columns)
      {
  # ifdef FEAT_MBYTE
  	if (enc_dbcs != 0 && dbcs_off2cells(off, max_off) > 1)
  	    screen_char_2(off, row, col);
  	else
  # endif
  	    screen_char(off, row, col);
      }
  #endif
  }
  
  #ifdef FEAT_SEARCH_EXTRA
  /*
   * Prepare for 'hlsearch' highlighting.
   */
      static void
  start_search_hl(void)
  {
      if (p_hls && !no_hlsearch)
      {
  	last_pat_prog(&search_hl.rm);
  	search_hl.attr = HL_ATTR(HLF_L);
  # ifdef FEAT_RELTIME
  	/* Set the time limit to 'redrawtime'. */
  	profile_setlimit(p_rdt, &search_hl.tm);
  # endif
      }
  }
  
  /*
   * Clean up for 'hlsearch' highlighting.
   */
      static void
  end_search_hl(void)
  {
      if (search_hl.rm.regprog != NULL)
      {
  	vim_regfree(search_hl.rm.regprog);
  	search_hl.rm.regprog = NULL;
      }
  }
  
  /*
   * Init for calling prepare_search_hl().
   */
      static void
  init_search_hl(win_T *wp)
  {
      matchitem_T *cur;
  
      /* Setup for match and 'hlsearch' highlighting.  Disable any previous
       * match */
      cur = wp->w_match_head;
      while (cur != NULL)
      {
  	cur->hl.rm = cur->match;
  	if (cur->hlg_id == 0)
  	    cur->hl.attr = 0;
  	else
  	    cur->hl.attr = syn_id2attr(cur->hlg_id);
  	cur->hl.buf = wp->w_buffer;
  	cur->hl.lnum = 0;
  	cur->hl.first_lnum = 0;
  # ifdef FEAT_RELTIME
  	/* Set the time limit to 'redrawtime'. */
  	profile_setlimit(p_rdt, &(cur->hl.tm));
  # endif
  	cur = cur->next;
      }
      search_hl.buf = wp->w_buffer;
      search_hl.lnum = 0;
      search_hl.first_lnum = 0;
      /* time limit is set at the toplevel, for all windows */
  }
  
  /*
   * Advance to the match in window "wp" line "lnum" or past it.
   */
      static void
  prepare_search_hl(win_T *wp, linenr_T lnum)
  {
      matchitem_T *cur;		/* points to the match list */
      match_T	*shl;		/* points to search_hl or a match */
      int		shl_flag;	/* flag to indicate whether search_hl
  				   has been processed or not */
      int		pos_inprogress;	/* marks that position match search is
  				   in progress */
      int		n;
  
      /*
       * When using a multi-line pattern, start searching at the top
       * of the window or just after a closed fold.
       * Do this both for search_hl and the match list.
       */
      cur = wp->w_match_head;
      shl_flag = FALSE;
      while (cur != NULL || shl_flag == FALSE)
      {
  	if (shl_flag == FALSE)
  	{
  	    shl = &search_hl;
  	    shl_flag = TRUE;
  	}
  	else
  	    shl = &cur->hl;
  	if (shl->rm.regprog != NULL
  		&& shl->lnum == 0
  		&& re_multiline(shl->rm.regprog))
  	{
  	    if (shl->first_lnum == 0)
  	    {
  # ifdef FEAT_FOLDING
  		for (shl->first_lnum = lnum;
  			   shl->first_lnum > wp->w_topline; --shl->first_lnum)
  		    if (hasFoldingWin(wp, shl->first_lnum - 1,
  						      NULL, NULL, TRUE, NULL))
  			break;
  # else
  		shl->first_lnum = wp->w_topline;
  # endif
  	    }
  	    if (cur != NULL)
  		cur->pos.cur = 0;
  	    pos_inprogress = TRUE;
  	    n = 0;
  	    while (shl->first_lnum < lnum && (shl->rm.regprog != NULL
  					  || (cur != NULL && pos_inprogress)))
  	    {
  		next_search_hl(wp, shl, shl->first_lnum, (colnr_T)n,
  					       shl == &search_hl ? NULL : cur);
  		pos_inprogress = cur == NULL || cur->pos.cur == 0
  							      ? FALSE : TRUE;
  		if (shl->lnum != 0)
  		{
  		    shl->first_lnum = shl->lnum
  				    + shl->rm.endpos[0].lnum
  				    - shl->rm.startpos[0].lnum;
  		    n = shl->rm.endpos[0].col;
  		}
  		else
  		{
  		    ++shl->first_lnum;
  		    n = 0;
  		}
  	    }
  	}
  	if (shl != &search_hl && cur != NULL)
  	    cur = cur->next;
      }
  }
  
  /*
   * Search for a next 'hlsearch' or match.
   * Uses shl->buf.
   * Sets shl->lnum and shl->rm contents.
   * Note: Assumes a previous match is always before "lnum", unless
   * shl->lnum is zero.
   * Careful: Any pointers for buffer lines will become invalid.
   */
      static void
  next_search_hl(
      win_T	    *win,
      match_T	    *shl,	/* points to search_hl or a match */
      linenr_T	    lnum,
      colnr_T	    mincol,	/* minimal column for a match */
      matchitem_T	    *cur)	/* to retrieve match positions if any */
  {
      linenr_T	l;
      colnr_T	matchcol;
      long	nmatched;
  
      if (shl->lnum != 0)
      {
  	/* Check for three situations:
  	 * 1. If the "lnum" is below a previous match, start a new search.
  	 * 2. If the previous match includes "mincol", use it.
  	 * 3. Continue after the previous match.
  	 */
  	l = shl->lnum + shl->rm.endpos[0].lnum - shl->rm.startpos[0].lnum;
  	if (lnum > l)
  	    shl->lnum = 0;
  	else if (lnum < l || shl->rm.endpos[0].col > mincol)
  	    return;
      }
  
      /*
       * Repeat searching for a match until one is found that includes "mincol"
       * or none is found in this line.
       */
      called_emsg = FALSE;
      for (;;)
      {
  #ifdef FEAT_RELTIME
  	/* Stop searching after passing the time limit. */
  	if (profile_passed_limit(&(shl->tm)))
  	{
  	    shl->lnum = 0;		/* no match found in time */
  	    break;
  	}
  #endif
  	/* Three situations:
  	 * 1. No useful previous match: search from start of line.
  	 * 2. Not Vi compatible or empty match: continue at next character.
  	 *    Break the loop if this is beyond the end of the line.
  	 * 3. Vi compatible searching: continue at end of previous match.
  	 */
  	if (shl->lnum == 0)
  	    matchcol = 0;
  	else if (vim_strchr(p_cpo, CPO_SEARCH) == NULL
  		|| (shl->rm.endpos[0].lnum == 0
  		    && shl->rm.endpos[0].col <= shl->rm.startpos[0].col))
  	{
  	    char_u	*ml;
  
  	    matchcol = shl->rm.startpos[0].col;
  	    ml = ml_get_buf(shl->buf, lnum, FALSE) + matchcol;
  	    if (*ml == NUL)
  	    {
  		++matchcol;
  		shl->lnum = 0;
  		break;
  	    }
  #ifdef FEAT_MBYTE
  	    if (has_mbyte)
  		matchcol += mb_ptr2len(ml);
  	    else
  #endif
  		++matchcol;
  	}
  	else
  	    matchcol = shl->rm.endpos[0].col;
  
  	shl->lnum = lnum;
  	if (shl->rm.regprog != NULL)
  	{
  	    /* Remember whether shl->rm is using a copy of the regprog in
  	     * cur->match. */
  	    int regprog_is_copy = (shl != &search_hl && cur != NULL
  				&& shl == &cur->hl
  				&& cur->match.regprog == cur->hl.rm.regprog);
  	    int timed_out = FALSE;
  
  	    nmatched = vim_regexec_multi(&shl->rm, win, shl->buf, lnum,
  		    matchcol,
  #ifdef FEAT_RELTIME
  		    &(shl->tm), &timed_out
  #else
  		    NULL, NULL
  #endif
  		    );
  	    /* Copy the regprog, in case it got freed and recompiled. */
  	    if (regprog_is_copy)
  		cur->match.regprog = cur->hl.rm.regprog;
  
  	    if (called_emsg || got_int || timed_out)
  	    {
  		/* Error while handling regexp: stop using this regexp. */
  		if (shl == &search_hl)
  		{
  		    /* don't free regprog in the match list, it's a copy */
  		    vim_regfree(shl->rm.regprog);
  		    SET_NO_HLSEARCH(TRUE);
  		}
  		shl->rm.regprog = NULL;
  		shl->lnum = 0;
  		got_int = FALSE;  /* avoid the "Type :quit to exit Vim"
  				     message */
  		break;
  	    }
  	}
  	else if (cur != NULL)
  	    nmatched = next_search_hl_pos(shl, lnum, &(cur->pos), matchcol);
  	else
  	    nmatched = 0;
  	if (nmatched == 0)
  	{
  	    shl->lnum = 0;		/* no match found */
  	    break;
  	}
  	if (shl->rm.startpos[0].lnum > 0
  		|| shl->rm.startpos[0].col >= mincol
  		|| nmatched > 1
  		|| shl->rm.endpos[0].col > mincol)
  	{
  	    shl->lnum += shl->rm.startpos[0].lnum;
  	    break;			/* useful match found */
  	}
      }
  }
  
  /*
   * If there is a match fill "shl" and return one.
   * Return zero otherwise.
   */
      static int
  next_search_hl_pos(
      match_T	    *shl,	/* points to a match */
      linenr_T	    lnum,
      posmatch_T	    *posmatch,	/* match positions */
      colnr_T	    mincol)	/* minimal column for a match */
  {
      int	    i;
      int	    found = -1;
  
      for (i = posmatch->cur; i < MAXPOSMATCH; i++)
      {
  	llpos_T	*pos = &posmatch->pos[i];
  
  	if (pos->lnum == 0)
  	    break;
  	if (pos->len == 0 && pos->col < mincol)
  	    continue;
  	if (pos->lnum == lnum)
  	{
  	    if (found >= 0)
  	    {
  		/* if this match comes before the one at "found" then swap
  		 * them */
  		if (pos->col < posmatch->pos[found].col)
  		{
  		    llpos_T	tmp = *pos;
  
  		    *pos = posmatch->pos[found];
  		    posmatch->pos[found] = tmp;
  		}
  	    }
  	    else
  		found = i;
  	}
      }
      posmatch->cur = 0;
      if (found >= 0)
      {
  	colnr_T	start = posmatch->pos[found].col == 0
  					    ? 0 : posmatch->pos[found].col - 1;
  	colnr_T	end = posmatch->pos[found].col == 0
  				   ? MAXCOL : start + posmatch->pos[found].len;
  
  	shl->lnum = lnum;
  	shl->rm.startpos[0].lnum = 0;
  	shl->rm.startpos[0].col = start;
  	shl->rm.endpos[0].lnum = 0;
  	shl->rm.endpos[0].col = end;
  	shl->is_addpos = TRUE;
  	posmatch->cur = found + 1;
  	return 1;
      }
      return 0;
  }
  #endif
  
        static void
  screen_start_highlight(int attr)
  {
      attrentry_T *aep = NULL;
  
      screen_attr = attr;
      if (full_screen
  #ifdef WIN3264
  		    && termcap_active
  #endif
  				       )
      {
  #ifdef FEAT_GUI
  	if (gui.in_use)
  	{
  	    char	buf[20];
  
  	    /* The GUI handles this internally. */
  	    sprintf(buf, IF_EB("\033|%dh", ESC_STR "|%dh"), attr);
  	    OUT_STR(buf);
  	}
  	else
  #endif
  	{
  	    if (attr > HL_ALL)				/* special HL attr. */
  	    {
  		if (IS_CTERM)
  		    aep = syn_cterm_attr2entry(attr);
  		else
  		    aep = syn_term_attr2entry(attr);
  		if (aep == NULL)	    /* did ":syntax clear" */
  		    attr = 0;
  		else
  		    attr = aep->ae_attr;
  	    }
  	    if ((attr & HL_BOLD) && *T_MD != NUL)	/* bold */
  		out_str(T_MD);
  	    else if (aep != NULL && cterm_normal_fg_bold && (
  #ifdef FEAT_TERMGUICOLORS
  			p_tgc && aep->ae_u.cterm.fg_rgb != CTERMCOLOR
  			  ? aep->ae_u.cterm.fg_rgb != INVALCOLOR
  			  :
  #endif
  			    t_colors > 1 && aep->ae_u.cterm.fg_color))
  		/* If the Normal FG color has BOLD attribute and the new HL
  		 * has a FG color defined, clear BOLD. */
  		out_str(T_ME);
  	    if ((attr & HL_STANDOUT) && *T_SO != NUL)	/* standout */
  		out_str(T_SO);
  	    if ((attr & HL_UNDERCURL) && *T_UCS != NUL) /* undercurl */
  		out_str(T_UCS);
  	    if (((attr & HL_UNDERLINE)	    /* underline or undercurl */
  			|| ((attr & HL_UNDERCURL) && *T_UCS == NUL))
  		    && *T_US != NUL)
  		out_str(T_US);
  	    if ((attr & HL_ITALIC) && *T_CZH != NUL)	/* italic */
  		out_str(T_CZH);
  	    if ((attr & HL_INVERSE) && *T_MR != NUL)	/* inverse (reverse) */
  		out_str(T_MR);
  	    if ((attr & HL_STRIKETHROUGH) && *T_STS != NUL)	/* strike */
  		out_str(T_STS);
  
  	    /*
  	     * Output the color or start string after bold etc., in case the
  	     * bold etc. override the color setting.
  	     */
  	    if (aep != NULL)
  	    {
  #ifdef FEAT_TERMGUICOLORS
  		/* When 'termguicolors' is set but fg or bg is unset,
  		 * fall back to the cterm colors.   This helps for SpellBad,
  		 * where the GUI uses a red undercurl. */
  		if (p_tgc && aep->ae_u.cterm.fg_rgb != CTERMCOLOR)
  		{
  		    if (aep->ae_u.cterm.fg_rgb != INVALCOLOR)
  			term_fg_rgb_color(aep->ae_u.cterm.fg_rgb);
  		}
  		else
  #endif
  		if (t_colors > 1)
  		{
  		    if (aep->ae_u.cterm.fg_color)
  			term_fg_color(aep->ae_u.cterm.fg_color - 1);
  		}
  #ifdef FEAT_TERMGUICOLORS
  		if (p_tgc && aep->ae_u.cterm.bg_rgb != CTERMCOLOR)
  		{
  		    if (aep->ae_u.cterm.bg_rgb != INVALCOLOR)
  			term_bg_rgb_color(aep->ae_u.cterm.bg_rgb);
  		}
  		else
  #endif
  		if (t_colors > 1)
  		{
  		    if (aep->ae_u.cterm.bg_color)
  			term_bg_color(aep->ae_u.cterm.bg_color - 1);
  		}
  
  		if (!IS_CTERM)
  		{
  		    if (aep->ae_u.term.start != NULL)
  			out_str(aep->ae_u.term.start);
  		}
  	    }
  	}
      }
  }
  
        void
  screen_stop_highlight(void)
  {
      int	    do_ME = FALSE;	    /* output T_ME code */
  
      if (screen_attr != 0
  #ifdef WIN3264
  			&& termcap_active
  #endif
  					   )
      {
  #ifdef FEAT_GUI
  	if (gui.in_use)
  	{
  	    char	buf[20];
  
  	    /* use internal GUI code */
  	    sprintf(buf, IF_EB("\033|%dH", ESC_STR "|%dH"), screen_attr);
  	    OUT_STR(buf);
  	}
  	else
  #endif
  	{
  	    if (screen_attr > HL_ALL)			/* special HL attr. */
  	    {
  		attrentry_T *aep;
  
  		if (IS_CTERM)
  		{
  		    /*
  		     * Assume that t_me restores the original colors!
  		     */
  		    aep = syn_cterm_attr2entry(screen_attr);
  		    if (aep != NULL && ((
  #ifdef FEAT_TERMGUICOLORS
  			    p_tgc && aep->ae_u.cterm.fg_rgb != CTERMCOLOR
  				? aep->ae_u.cterm.fg_rgb != INVALCOLOR
  				:
  #endif
  				aep->ae_u.cterm.fg_color) || (
  #ifdef FEAT_TERMGUICOLORS
  			    p_tgc && aep->ae_u.cterm.bg_rgb != CTERMCOLOR
  				? aep->ae_u.cterm.bg_rgb != INVALCOLOR
  				:
  #endif
  				aep->ae_u.cterm.bg_color)))
  			do_ME = TRUE;
  		}
  		else
  		{
  		    aep = syn_term_attr2entry(screen_attr);
  		    if (aep != NULL && aep->ae_u.term.stop != NULL)
  		    {
  			if (STRCMP(aep->ae_u.term.stop, T_ME) == 0)
  			    do_ME = TRUE;
  			else
  			    out_str(aep->ae_u.term.stop);
  		    }
  		}
  		if (aep == NULL)	    /* did ":syntax clear" */
  		    screen_attr = 0;
  		else
  		    screen_attr = aep->ae_attr;
  	    }
  
  	    /*
  	     * Often all ending-codes are equal to T_ME.  Avoid outputting the
  	     * same sequence several times.
  	     */
  	    if (screen_attr & HL_STANDOUT)
  	    {
  		if (STRCMP(T_SE, T_ME) == 0)
  		    do_ME = TRUE;
  		else
  		    out_str(T_SE);
  	    }
  	    if ((screen_attr & HL_UNDERCURL) && *T_UCE != NUL)
  	    {
  		if (STRCMP(T_UCE, T_ME) == 0)
  		    do_ME = TRUE;
  		else
  		    out_str(T_UCE);
  	    }
  	    if ((screen_attr & HL_UNDERLINE)
  			    || ((screen_attr & HL_UNDERCURL) && *T_UCE == NUL))
  	    {
  		if (STRCMP(T_UE, T_ME) == 0)
  		    do_ME = TRUE;
  		else
  		    out_str(T_UE);
  	    }
  	    if (screen_attr & HL_ITALIC)
  	    {
  		if (STRCMP(T_CZR, T_ME) == 0)
  		    do_ME = TRUE;
  		else
  		    out_str(T_CZR);
  	    }
  	    if (screen_attr & HL_STRIKETHROUGH)
  	    {
  		if (STRCMP(T_STE, T_ME) == 0)
  		    do_ME = TRUE;
  		else
  		    out_str(T_STE);
  	    }
  	    if (do_ME || (screen_attr & (HL_BOLD | HL_INVERSE)))
  		out_str(T_ME);
  
  #ifdef FEAT_TERMGUICOLORS
  	    if (p_tgc)
  	    {
  		if (cterm_normal_fg_gui_color != INVALCOLOR)
  		    term_fg_rgb_color(cterm_normal_fg_gui_color);
  		if (cterm_normal_bg_gui_color != INVALCOLOR)
  		    term_bg_rgb_color(cterm_normal_bg_gui_color);
  	    }
  	    else
  #endif
  	    {
  		if (t_colors > 1)
  		{
  		    /* set Normal cterm colors */
  		    if (cterm_normal_fg_color != 0)
  			term_fg_color(cterm_normal_fg_color - 1);
  		    if (cterm_normal_bg_color != 0)
  			term_bg_color(cterm_normal_bg_color - 1);
  		    if (cterm_normal_fg_bold)
  			out_str(T_MD);
  		}
  	    }
  	}
      }
      screen_attr = 0;
  }
  
  /*
   * Reset the colors for a cterm.  Used when leaving Vim.
   * The machine specific code may override this again.
   */
      void
  reset_cterm_colors(void)
  {
      if (IS_CTERM)
      {
  	/* set Normal cterm colors */
  #ifdef FEAT_TERMGUICOLORS
  	if (p_tgc ? (cterm_normal_fg_gui_color != INVALCOLOR
  		 || cterm_normal_bg_gui_color != INVALCOLOR)
  		: (cterm_normal_fg_color > 0 || cterm_normal_bg_color > 0))
  #else
  	if (cterm_normal_fg_color > 0 || cterm_normal_bg_color > 0)
  #endif
  	{
  	    out_str(T_OP);
  	    screen_attr = -1;
  	}
  	if (cterm_normal_fg_bold)
  	{
  	    out_str(T_ME);
  	    screen_attr = -1;
  	}
      }
  }
  
  /*
   * Put character ScreenLines["off"] on the screen at position "row" and "col",
   * using the attributes from ScreenAttrs["off"].
   */
      static void
  screen_char(unsigned off, int row, int col)
  {
      int		attr;
  
      /* Check for illegal values, just in case (could happen just after
       * resizing). */
      if (row >= screen_Rows || col >= screen_Columns)
  	return;
  
      /* Outputting a character in the last cell on the screen may scroll the
       * screen up.  Only do it when the "xn" termcap property is set, otherwise
       * mark the character invalid (update it when scrolled up). */
      if (*T_XN == NUL
  	    && row == screen_Rows - 1 && col == screen_Columns - 1
  #ifdef FEAT_RIGHTLEFT
  	    /* account for first command-line character in rightleft mode */
  	    && !cmdmsg_rl
  #endif
         )
      {
  	ScreenAttrs[off] = (sattr_T)-1;
  	return;
      }
  
      /*
       * Stop highlighting first, so it's easier to move the cursor.
       */
      if (screen_char_attr != 0)
  	attr = screen_char_attr;
      else
  	attr = ScreenAttrs[off];
      if (screen_attr != attr)
  	screen_stop_highlight();
  
      windgoto(row, col);
  
      if (screen_attr != attr)
  	screen_start_highlight(attr);
  
  #ifdef FEAT_MBYTE
      if (enc_utf8 && ScreenLinesUC[off] != 0)
      {
  	char_u	    buf[MB_MAXBYTES + 1];
  
  	if (utf_ambiguous_width(ScreenLinesUC[off]))
  	{
  	    if (*p_ambw == 'd'
  # ifdef FEAT_GUI
  		    && !gui.in_use
  # endif
  		    )
  	    {
  		/* Clear the two screen cells. If the character is actually
  		 * single width it won't change the second cell. */
  		out_str((char_u *)"  ");
  		term_windgoto(row, col);
  	    }
  	    /* not sure where the cursor is after drawing the ambiguous width
  	     * character */
  	    screen_cur_col = 9999;
  	}
  	else if (utf_char2cells(ScreenLinesUC[off]) > 1)
  	    ++screen_cur_col;
  
  	/* Convert the UTF-8 character to bytes and write it. */
  	buf[utfc_char2bytes(off, buf)] = NUL;
  	out_str(buf);
      }
      else
  #endif
      {
  #ifdef FEAT_MBYTE
  	out_flush_check();
  #endif
  	out_char(ScreenLines[off]);
  #ifdef FEAT_MBYTE
  	/* double-byte character in single-width cell */
  	if (enc_dbcs == DBCS_JPNU && ScreenLines[off] == 0x8e)
  	    out_char(ScreenLines2[off]);
  #endif
      }
  
      screen_cur_col++;
  }
  
  #ifdef FEAT_MBYTE
  
  /*
   * Used for enc_dbcs only: Put one double-wide character at ScreenLines["off"]
   * on the screen at position 'row' and 'col'.
   * The attributes of the first byte is used for all.  This is required to
   * output the two bytes of a double-byte character with nothing in between.
   */
      static void
  screen_char_2(unsigned off, int row, int col)
  {
      /* Check for illegal values (could be wrong when screen was resized). */
      if (off + 1 >= (unsigned)(screen_Rows * screen_Columns))
  	return;
  
      /* Outputting the last character on the screen may scrollup the screen.
       * Don't to it!  Mark the character invalid (update it when scrolled up) */
      if (row == screen_Rows - 1 && col >= screen_Columns - 2)
      {
  	ScreenAttrs[off] = (sattr_T)-1;
  	return;
      }
  
      /* Output the first byte normally (positions the cursor), then write the
       * second byte directly. */
      screen_char(off, row, col);
      out_char(ScreenLines[off + 1]);
      ++screen_cur_col;
  }
  #endif
  
  /*
   * Draw a rectangle of the screen, inverted when "invert" is TRUE.
   * This uses the contents of ScreenLines[] and doesn't change it.
   */
      void
  screen_draw_rectangle(
      int		row,
      int		col,
      int		height,
      int		width,
      int		invert)
  {
      int		r, c;
      int		off;
  #ifdef FEAT_MBYTE
      int		max_off;
  #endif
  
      /* Can't use ScreenLines unless initialized */
      if (ScreenLines == NULL)
  	return;
  
      if (invert)
  	screen_char_attr = HL_INVERSE;
      for (r = row; r < row + height; ++r)
      {
  	off = LineOffset[r];
  #ifdef FEAT_MBYTE
  	max_off = off + screen_Columns;
  #endif
  	for (c = col; c < col + width; ++c)
  	{
  #ifdef FEAT_MBYTE
  	    if (enc_dbcs != 0 && dbcs_off2cells(off + c, max_off) > 1)
  	    {
  		screen_char_2(off + c, r, c);
  		++c;
  	    }
  	    else
  #endif
  	    {
  		screen_char(off + c, r, c);
  #ifdef FEAT_MBYTE
  		if (utf_off2cells(off + c, max_off) > 1)
  		    ++c;
  #endif
  	    }
  	}
      }
      screen_char_attr = 0;
  }
  
  /*
   * Redraw the characters for a vertically split window.
   */
      static void
  redraw_block(int row, int end, win_T *wp)
  {
      int		col;
      int		width;
  
  # ifdef FEAT_CLIPBOARD
      clip_may_clear_selection(row, end - 1);
  # endif
  
      if (wp == NULL)
      {
  	col = 0;
  	width = Columns;
      }
      else
      {
  	col = wp->w_wincol;
  	width = wp->w_width;
      }
      screen_draw_rectangle(row, col, end - row, width, FALSE);
  }
  
      static void
  space_to_screenline(int off, int attr)
  {
      ScreenLines[off] = ' ';
      ScreenAttrs[off] = attr;
  # ifdef FEAT_MBYTE
      if (enc_utf8)
  	ScreenLinesUC[off] = 0;
  # endif
  }
  
  /*
   * Fill the screen from 'start_row' to 'end_row', from 'start_col' to 'end_col'
   * with character 'c1' in first column followed by 'c2' in the other columns.
   * Use attributes 'attr'.
   */
      void
  screen_fill(
      int	    start_row,
      int	    end_row,
      int	    start_col,
      int	    end_col,
      int	    c1,
      int	    c2,
      int	    attr)
  {
      int		    row;
      int		    col;
      int		    off;
      int		    end_off;
      int		    did_delete;
      int		    c;
      int		    norm_term;
  #if defined(FEAT_GUI) || defined(UNIX)
      int		    force_next = FALSE;
  #endif
  
      if (end_row > screen_Rows)		/* safety check */
  	end_row = screen_Rows;
      if (end_col > screen_Columns)	/* safety check */
  	end_col = screen_Columns;
      if (ScreenLines == NULL
  	    || start_row >= end_row
  	    || start_col >= end_col)	/* nothing to do */
  	return;
  
      /* it's a "normal" terminal when not in a GUI or cterm */
      norm_term = (
  #ifdef FEAT_GUI
  	    !gui.in_use &&
  #endif
  	    !IS_CTERM);
      for (row = start_row; row < end_row; ++row)
      {
  #ifdef FEAT_MBYTE
  	if (has_mbyte
  # ifdef FEAT_GUI
  		&& !gui.in_use
  # endif
  	   )
  	{
  	    /* When drawing over the right halve of a double-wide char clear
  	     * out the left halve.  When drawing over the left halve of a
  	     * double wide-char clear out the right halve.  Only needed in a
  	     * terminal. */
  	    if (start_col > 0 && mb_fix_col(start_col, row) != start_col)
  		screen_puts_len((char_u *)" ", 1, row, start_col - 1, 0);
  	    if (end_col < screen_Columns && mb_fix_col(end_col, row) != end_col)
  		screen_puts_len((char_u *)" ", 1, row, end_col, 0);
  	}
  #endif
  	/*
  	 * Try to use delete-line termcap code, when no attributes or in a
  	 * "normal" terminal, where a bold/italic space is just a
  	 * space.
  	 */
  	did_delete = FALSE;
  	if (c2 == ' '
  		&& end_col == Columns
  		&& can_clear(T_CE)
  		&& (attr == 0
  		    || (norm_term
  			&& attr <= HL_ALL
  			&& ((attr & ~(HL_BOLD | HL_ITALIC)) == 0))))
  	{
  	    /*
  	     * check if we really need to clear something
  	     */
  	    col = start_col;
  	    if (c1 != ' ')			/* don't clear first char */
  		++col;
  
  	    off = LineOffset[row] + col;
  	    end_off = LineOffset[row] + end_col;
  
  	    /* skip blanks (used often, keep it fast!) */
  #ifdef FEAT_MBYTE
  	    if (enc_utf8)
  		while (off < end_off && ScreenLines[off] == ' '
  			  && ScreenAttrs[off] == 0 && ScreenLinesUC[off] == 0)
  		    ++off;
  	    else
  #endif
  		while (off < end_off && ScreenLines[off] == ' '
  						     && ScreenAttrs[off] == 0)
  		    ++off;
  	    if (off < end_off)		/* something to be cleared */
  	    {
  		col = off - LineOffset[row];
  		screen_stop_highlight();
  		term_windgoto(row, col);/* clear rest of this screen line */
  		out_str(T_CE);
  		screen_start();		/* don't know where cursor is now */
  		col = end_col - col;
  		while (col--)		/* clear chars in ScreenLines */
  		{
  		    space_to_screenline(off, 0);
  		    ++off;
  		}
  	    }
  	    did_delete = TRUE;		/* the chars are cleared now */
  	}
  
  	off = LineOffset[row] + start_col;
  	c = c1;
  	for (col = start_col; col < end_col; ++col)
  	{
  	    if (ScreenLines[off] != c
  #ifdef FEAT_MBYTE
  		    || (enc_utf8 && (int)ScreenLinesUC[off]
  						       != (c >= 0x80 ? c : 0))
  #endif
  		    || ScreenAttrs[off] != attr
  #if defined(FEAT_GUI) || defined(UNIX)
  		    || force_next
  #endif
  		    )
  	    {
  #if defined(FEAT_GUI) || defined(UNIX)
  		/* The bold trick may make a single row of pixels appear in
  		 * the next character.  When a bold character is removed, the
  		 * next character should be redrawn too.  This happens for our
  		 * own GUI and for some xterms.  */
  		if (
  # ifdef FEAT_GUI
  			gui.in_use
  # endif
  # if defined(FEAT_GUI) && defined(UNIX)
  			||
  # endif
  # ifdef UNIX
  			term_is_xterm
  # endif
  		   )
  		{
  		    if (ScreenLines[off] != ' '
  			    && (ScreenAttrs[off] > HL_ALL
  				|| ScreenAttrs[off] & HL_BOLD))
  			force_next = TRUE;
  		    else
  			force_next = FALSE;
  		}
  #endif
  		ScreenLines[off] = c;
  #ifdef FEAT_MBYTE
  		if (enc_utf8)
  		{
  		    if (c >= 0x80)
  		    {
  			ScreenLinesUC[off] = c;
  			ScreenLinesC[0][off] = 0;
  		    }
  		    else
  			ScreenLinesUC[off] = 0;
  		}
  #endif
  		ScreenAttrs[off] = attr;
  		if (!did_delete || c != ' ')
  		    screen_char(off, row, col);
  	    }
  	    ++off;
  	    if (col == start_col)
  	    {
  		if (did_delete)
  		    break;
  		c = c2;
  	    }
  	}
  	if (end_col == Columns)
  	    LineWraps[row] = FALSE;
  	if (row == Rows - 1)		/* overwritten the command line */
  	{
  	    redraw_cmdline = TRUE;
  	    if (start_col == 0 && end_col == Columns
  		    && c1 == ' ' && c2 == ' ' && attr == 0)
  		clear_cmdline = FALSE;	/* command line has been cleared */
  	    if (start_col == 0)
  		mode_displayed = FALSE; /* mode cleared or overwritten */
  	}
      }
  }
  
  /*
   * Check if there should be a delay.  Used before clearing or redrawing the
   * screen or the command line.
   */
      void
  check_for_delay(int check_msg_scroll)
  {
      if ((emsg_on_display || (check_msg_scroll && msg_scroll))
  	    && !did_wait_return
  	    && emsg_silent == 0)
      {
  	out_flush();
  	ui_delay(1000L, TRUE);
  	emsg_on_display = FALSE;
  	if (check_msg_scroll)
  	    msg_scroll = FALSE;
      }
  }
  
  /*
   * screen_valid -  allocate screen buffers if size changed
   *   If "doclear" is TRUE: clear screen if it has been resized.
   *	Returns TRUE if there is a valid screen to write to.
   *	Returns FALSE when starting up and screen not initialized yet.
   */
      int
  screen_valid(int doclear)
  {
      screenalloc(doclear);	   /* allocate screen buffers if size changed */
      return (ScreenLines != NULL);
  }
  
  /*
   * Resize the shell to Rows and Columns.
   * Allocate ScreenLines[] and associated items.
   *
   * There may be some time between setting Rows and Columns and (re)allocating
   * ScreenLines[].  This happens when starting up and when (manually) changing
   * the shell size.  Always use screen_Rows and screen_Columns to access items
   * in ScreenLines[].  Use Rows and Columns for positioning text etc. where the
   * final size of the shell is needed.
   */
      void
  screenalloc(int doclear)
  {
      int		    new_row, old_row;
  #ifdef FEAT_GUI
      int		    old_Rows;
  #endif
      win_T	    *wp;
      int		    outofmem = FALSE;
      int		    len;
      schar_T	    *new_ScreenLines;
  #ifdef FEAT_MBYTE
      u8char_T	    *new_ScreenLinesUC = NULL;
      u8char_T	    *new_ScreenLinesC[MAX_MCO];
      schar_T	    *new_ScreenLines2 = NULL;
      int		    i;
  #endif
      sattr_T	    *new_ScreenAttrs;
      unsigned	    *new_LineOffset;
      char_u	    *new_LineWraps;
      short	    *new_TabPageIdxs;
      tabpage_T	    *tp;
      static int	    entered = FALSE;		/* avoid recursiveness */
      static int	    done_outofmem_msg = FALSE;	/* did outofmem message */
      int		    retry_count = 0;
  
  retry:
      /*
       * Allocation of the screen buffers is done only when the size changes and
       * when Rows and Columns have been set and we have started doing full
       * screen stuff.
       */
      if ((ScreenLines != NULL
  		&& Rows == screen_Rows
  		&& Columns == screen_Columns
  #ifdef FEAT_MBYTE
  		&& enc_utf8 == (ScreenLinesUC != NULL)
  		&& (enc_dbcs == DBCS_JPNU) == (ScreenLines2 != NULL)
  		&& p_mco == Screen_mco
  #endif
  		)
  	    || Rows == 0
  	    || Columns == 0
  	    || (!full_screen && ScreenLines == NULL))
  	return;
  
      /*
       * It's possible that we produce an out-of-memory message below, which
       * will cause this function to be called again.  To break the loop, just
       * return here.
       */
      if (entered)
  	return;
      entered = TRUE;
  
      /*
       * Note that the window sizes are updated before reallocating the arrays,
       * thus we must not redraw here!
       */
      ++RedrawingDisabled;
  
      win_new_shellsize();    /* fit the windows in the new sized shell */
  
      comp_col();		/* recompute columns for shown command and ruler */
  
      /*
       * We're changing the size of the screen.
       * - Allocate new arrays for ScreenLines and ScreenAttrs.
       * - Move lines from the old arrays into the new arrays, clear extra
       *	 lines (unless the screen is going to be cleared).
       * - Free the old arrays.
       *
       * If anything fails, make ScreenLines NULL, so we don't do anything!
       * Continuing with the old ScreenLines may result in a crash, because the
       * size is wrong.
       */
      FOR_ALL_TAB_WINDOWS(tp, wp)
  	win_free_lsize(wp);
      if (aucmd_win != NULL)
  	win_free_lsize(aucmd_win);
  
      new_ScreenLines = (schar_T *)lalloc((long_u)(
  			      (Rows + 1) * Columns * sizeof(schar_T)), FALSE);
  #ifdef FEAT_MBYTE
      vim_memset(new_ScreenLinesC, 0, sizeof(u8char_T *) * MAX_MCO);
      if (enc_utf8)
      {
  	new_ScreenLinesUC = (u8char_T *)lalloc((long_u)(
  			     (Rows + 1) * Columns * sizeof(u8char_T)), FALSE);
  	for (i = 0; i < p_mco; ++i)
  	    new_ScreenLinesC[i] = (u8char_T *)lalloc_clear((long_u)(
  			     (Rows + 1) * Columns * sizeof(u8char_T)), FALSE);
      }
      if (enc_dbcs == DBCS_JPNU)
  	new_ScreenLines2 = (schar_T *)lalloc((long_u)(
  			     (Rows + 1) * Columns * sizeof(schar_T)), FALSE);
  #endif
      new_ScreenAttrs = (sattr_T *)lalloc((long_u)(
  			      (Rows + 1) * Columns * sizeof(sattr_T)), FALSE);
      new_LineOffset = (unsigned *)lalloc((long_u)(
  					 Rows * sizeof(unsigned)), FALSE);
      new_LineWraps = (char_u *)lalloc((long_u)(Rows * sizeof(char_u)), FALSE);
      new_TabPageIdxs = (short *)lalloc((long_u)(Columns * sizeof(short)), FALSE);
  
      FOR_ALL_TAB_WINDOWS(tp, wp)
      {
  	if (win_alloc_lines(wp) == FAIL)
  	{
  	    outofmem = TRUE;
  	    goto give_up;
  	}
      }
      if (aucmd_win != NULL && aucmd_win->w_lines == NULL
  					&& win_alloc_lines(aucmd_win) == FAIL)
  	outofmem = TRUE;
  give_up:
  
  #ifdef FEAT_MBYTE
      for (i = 0; i < p_mco; ++i)
  	if (new_ScreenLinesC[i] == NULL)
  	    break;
  #endif
      if (new_ScreenLines == NULL
  #ifdef FEAT_MBYTE
  	    || (enc_utf8 && (new_ScreenLinesUC == NULL || i != p_mco))
  	    || (enc_dbcs == DBCS_JPNU && new_ScreenLines2 == NULL)
  #endif
  	    || new_ScreenAttrs == NULL
  	    || new_LineOffset == NULL
  	    || new_LineWraps == NULL
  	    || new_TabPageIdxs == NULL
  	    || outofmem)
      {
  	if (ScreenLines != NULL || !done_outofmem_msg)
  	{
  	    /* guess the size */
  	    do_outofmem_msg((long_u)((Rows + 1) * Columns));
  
  	    /* Remember we did this to avoid getting outofmem messages over
  	     * and over again. */
  	    done_outofmem_msg = TRUE;
  	}
  	VIM_CLEAR(new_ScreenLines);
  #ifdef FEAT_MBYTE
  	VIM_CLEAR(new_ScreenLinesUC);
  	for (i = 0; i < p_mco; ++i)
  	    VIM_CLEAR(new_ScreenLinesC[i]);
  	VIM_CLEAR(new_ScreenLines2);
  #endif
  	VIM_CLEAR(new_ScreenAttrs);
  	VIM_CLEAR(new_LineOffset);
  	VIM_CLEAR(new_LineWraps);
  	VIM_CLEAR(new_TabPageIdxs);
      }
      else
      {
  	done_outofmem_msg = FALSE;
  
  	for (new_row = 0; new_row < Rows; ++new_row)
  	{
  	    new_LineOffset[new_row] = new_row * Columns;
  	    new_LineWraps[new_row] = FALSE;
  
  	    /*
  	     * If the screen is not going to be cleared, copy as much as
  	     * possible from the old screen to the new one and clear the rest
  	     * (used when resizing the window at the "--more--" prompt or when
  	     * executing an external command, for the GUI).
  	     */
  	    if (!doclear)
  	    {
  		(void)vim_memset(new_ScreenLines + new_row * Columns,
  				      ' ', (size_t)Columns * sizeof(schar_T));
  #ifdef FEAT_MBYTE
  		if (enc_utf8)
  		{
  		    (void)vim_memset(new_ScreenLinesUC + new_row * Columns,
  				       0, (size_t)Columns * sizeof(u8char_T));
  		    for (i = 0; i < p_mco; ++i)
  			(void)vim_memset(new_ScreenLinesC[i]
  							  + new_row * Columns,
  				       0, (size_t)Columns * sizeof(u8char_T));
  		}
  		if (enc_dbcs == DBCS_JPNU)
  		    (void)vim_memset(new_ScreenLines2 + new_row * Columns,
  				       0, (size_t)Columns * sizeof(schar_T));
  #endif
  		(void)vim_memset(new_ScreenAttrs + new_row * Columns,
  					0, (size_t)Columns * sizeof(sattr_T));
  		old_row = new_row + (screen_Rows - Rows);
  		if (old_row >= 0 && ScreenLines != NULL)
  		{
  		    if (screen_Columns < Columns)
  			len = screen_Columns;
  		    else
  			len = Columns;
  #ifdef FEAT_MBYTE
  		    /* When switching to utf-8 don't copy characters, they
  		     * may be invalid now.  Also when p_mco changes. */
  		    if (!(enc_utf8 && ScreenLinesUC == NULL)
  						       && p_mco == Screen_mco)
  #endif
  			mch_memmove(new_ScreenLines + new_LineOffset[new_row],
  				ScreenLines + LineOffset[old_row],
  				(size_t)len * sizeof(schar_T));
  #ifdef FEAT_MBYTE
  		    if (enc_utf8 && ScreenLinesUC != NULL
  						       && p_mco == Screen_mco)
  		    {
  			mch_memmove(new_ScreenLinesUC + new_LineOffset[new_row],
  				ScreenLinesUC + LineOffset[old_row],
  				(size_t)len * sizeof(u8char_T));
  			for (i = 0; i < p_mco; ++i)
  			    mch_memmove(new_ScreenLinesC[i]
  						    + new_LineOffset[new_row],
  				ScreenLinesC[i] + LineOffset[old_row],
  				(size_t)len * sizeof(u8char_T));
  		    }
  		    if (enc_dbcs == DBCS_JPNU && ScreenLines2 != NULL)
  			mch_memmove(new_ScreenLines2 + new_LineOffset[new_row],
  				ScreenLines2 + LineOffset[old_row],
  				(size_t)len * sizeof(schar_T));
  #endif
  		    mch_memmove(new_ScreenAttrs + new_LineOffset[new_row],
  			    ScreenAttrs + LineOffset[old_row],
  			    (size_t)len * sizeof(sattr_T));
  		}
  	    }
  	}
  	/* Use the last line of the screen for the current line. */
  	current_ScreenLine = new_ScreenLines + Rows * Columns;
      }
  
      free_screenlines();
  
      ScreenLines = new_ScreenLines;
  #ifdef FEAT_MBYTE
      ScreenLinesUC = new_ScreenLinesUC;
      for (i = 0; i < p_mco; ++i)
  	ScreenLinesC[i] = new_ScreenLinesC[i];
      Screen_mco = p_mco;
      ScreenLines2 = new_ScreenLines2;
  #endif
      ScreenAttrs = new_ScreenAttrs;
      LineOffset = new_LineOffset;
      LineWraps = new_LineWraps;
      TabPageIdxs = new_TabPageIdxs;
  
      /* It's important that screen_Rows and screen_Columns reflect the actual
       * size of ScreenLines[].  Set them before calling anything. */
  #ifdef FEAT_GUI
      old_Rows = screen_Rows;
  #endif
      screen_Rows = Rows;
      screen_Columns = Columns;
  
      must_redraw = CLEAR;	/* need to clear the screen later */
      if (doclear)
  	screenclear2();
  
  #ifdef FEAT_GUI
      else if (gui.in_use
  	    && !gui.starting
  	    && ScreenLines != NULL
  	    && old_Rows != Rows)
      {
  	(void)gui_redraw_block(0, 0, (int)Rows - 1, (int)Columns - 1, 0);
  	/*
  	 * Adjust the position of the cursor, for when executing an external
  	 * command.
  	 */
  	if (msg_row >= Rows)		/* Rows got smaller */
  	    msg_row = Rows - 1;		/* put cursor at last row */
  	else if (Rows > old_Rows)	/* Rows got bigger */
  	    msg_row += Rows - old_Rows; /* put cursor in same place */
  	if (msg_col >= Columns)		/* Columns got smaller */
  	    msg_col = Columns - 1;	/* put cursor at last column */
      }
  #endif
  
      entered = FALSE;
      --RedrawingDisabled;
  
      /*
       * Do not apply autocommands more than 3 times to avoid an endless loop
       * in case applying autocommands always changes Rows or Columns.
       */
      if (starting == 0 && ++retry_count <= 3)
      {
  	apply_autocmds(EVENT_VIMRESIZED, NULL, NULL, FALSE, curbuf);
  	/* In rare cases, autocommands may have altered Rows or Columns,
  	 * jump back to check if we need to allocate the screen again. */
  	goto retry;
      }
  }
  
      void
  free_screenlines(void)
  {
  #ifdef FEAT_MBYTE
      int		i;
  
      vim_free(ScreenLinesUC);
      for (i = 0; i < Screen_mco; ++i)
  	vim_free(ScreenLinesC[i]);
      vim_free(ScreenLines2);
  #endif
      vim_free(ScreenLines);
      vim_free(ScreenAttrs);
      vim_free(LineOffset);
      vim_free(LineWraps);
      vim_free(TabPageIdxs);
  }
  
      void
  screenclear(void)
  {
      check_for_delay(FALSE);
      screenalloc(FALSE);	    /* allocate screen buffers if size changed */
      screenclear2();	    /* clear the screen */
  }
  
      static void
  screenclear2(void)
  {
      int	    i;
  
      if (starting == NO_SCREEN || ScreenLines == NULL
  #ifdef FEAT_GUI
  	    || (gui.in_use && gui.starting)
  #endif
  	    )
  	return;
  
  #ifdef FEAT_GUI
      if (!gui.in_use)
  #endif
  	screen_attr = -1;	/* force setting the Normal colors */
      screen_stop_highlight();	/* don't want highlighting here */
  
  #ifdef FEAT_CLIPBOARD
      /* disable selection without redrawing it */
      clip_scroll_selection(9999);
  #endif
  
      /* blank out ScreenLines */
      for (i = 0; i < Rows; ++i)
      {
  	lineclear(LineOffset[i], (int)Columns, 0);
  	LineWraps[i] = FALSE;
      }
  
      if (can_clear(T_CL))
      {
  	out_str(T_CL);		/* clear the display */
  	clear_cmdline = FALSE;
  	mode_displayed = FALSE;
      }
      else
      {
  	/* can't clear the screen, mark all chars with invalid attributes */
  	for (i = 0; i < Rows; ++i)
  	    lineinvalid(LineOffset[i], (int)Columns);
  	clear_cmdline = TRUE;
      }
  
      screen_cleared = TRUE;	/* can use contents of ScreenLines now */
  
      win_rest_invalid(firstwin);
      redraw_cmdline = TRUE;
      redraw_tabline = TRUE;
      if (must_redraw == CLEAR)	/* no need to clear again */
  	must_redraw = NOT_VALID;
      compute_cmdrow();
      msg_row = cmdline_row;	/* put cursor on last line for messages */
      msg_col = 0;
      screen_start();		/* don't know where cursor is now */
      msg_scrolled = 0;		/* can't scroll back */
      msg_didany = FALSE;
      msg_didout = FALSE;
  }
  
  /*
   * Clear one line in ScreenLines.
   */
      static void
  lineclear(unsigned off, int width, int attr)
  {
      (void)vim_memset(ScreenLines + off, ' ', (size_t)width * sizeof(schar_T));
  #ifdef FEAT_MBYTE
      if (enc_utf8)
  	(void)vim_memset(ScreenLinesUC + off, 0,
  					  (size_t)width * sizeof(u8char_T));
  #endif
      (void)vim_memset(ScreenAttrs + off, attr, (size_t)width * sizeof(sattr_T));
  }
  
  /*
   * Mark one line in ScreenLines invalid by setting the attributes to an
   * invalid value.
   */
      static void
  lineinvalid(unsigned off, int width)
  {
      (void)vim_memset(ScreenAttrs + off, -1, (size_t)width * sizeof(sattr_T));
  }
  
  /*
   * Copy part of a Screenline for vertically split window "wp".
   */
      static void
  linecopy(int to, int from, win_T *wp)
  {
      unsigned	off_to = LineOffset[to] + wp->w_wincol;
      unsigned	off_from = LineOffset[from] + wp->w_wincol;
  
      mch_memmove(ScreenLines + off_to, ScreenLines + off_from,
  	    wp->w_width * sizeof(schar_T));
  #ifdef FEAT_MBYTE
      if (enc_utf8)
      {
  	int	i;
  
  	mch_memmove(ScreenLinesUC + off_to, ScreenLinesUC + off_from,
  		wp->w_width * sizeof(u8char_T));
  	for (i = 0; i < p_mco; ++i)
  	    mch_memmove(ScreenLinesC[i] + off_to, ScreenLinesC[i] + off_from,
  		    wp->w_width * sizeof(u8char_T));
      }
      if (enc_dbcs == DBCS_JPNU)
  	mch_memmove(ScreenLines2 + off_to, ScreenLines2 + off_from,
  		wp->w_width * sizeof(schar_T));
  #endif
      mch_memmove(ScreenAttrs + off_to, ScreenAttrs + off_from,
  	    wp->w_width * sizeof(sattr_T));
  }
  
  /*
   * Return TRUE if clearing with term string "p" would work.
   * It can't work when the string is empty or it won't set the right background.
   */
      int
  can_clear(char_u *p)
  {
      return (*p != NUL && (t_colors <= 1
  #ifdef FEAT_GUI
  		|| gui.in_use
  #endif
  #ifdef FEAT_TERMGUICOLORS
  		|| (p_tgc && cterm_normal_bg_gui_color == INVALCOLOR)
  		|| (!p_tgc && cterm_normal_bg_color == 0)
  #else
  		|| cterm_normal_bg_color == 0
  #endif
  		|| *T_UT != NUL));
  }
  
  /*
   * Reset cursor position. Use whenever cursor was moved because of outputting
   * something directly to the screen (shell commands) or a terminal control
   * code.
   */
      void
  screen_start(void)
  {
      screen_cur_row = screen_cur_col = 9999;
  }
  
  /*
   * Move the cursor to position "row","col" in the screen.
   * This tries to find the most efficient way to move, minimizing the number of
   * characters sent to the terminal.
   */
      void
  windgoto(int row, int col)
  {
      sattr_T	    *p;
      int		    i;
      int		    plan;
      int		    cost;
      int		    wouldbe_col;
      int		    noinvcurs;
      char_u	    *bs;
      int		    goto_cost;
      int		    attr;
  
  #define GOTO_COST   7	/* assume a term_windgoto() takes about 7 chars */
  #define HIGHL_COST  5	/* assume unhighlight takes 5 chars */
  
  #define PLAN_LE	    1
  #define PLAN_CR	    2
  #define PLAN_NL	    3
  #define PLAN_WRITE  4
      /* Can't use ScreenLines unless initialized */
      if (ScreenLines == NULL)
  	return;
  
      if (col != screen_cur_col || row != screen_cur_row)
      {
  	/* Check for valid position. */
  	if (row < 0)	/* window without text lines? */
  	    row = 0;
  	if (row >= screen_Rows)
  	    row = screen_Rows - 1;
  	if (col >= screen_Columns)
  	    col = screen_Columns - 1;
  
  	/* check if no cursor movement is allowed in highlight mode */
  	if (screen_attr && *T_MS == NUL)
  	    noinvcurs = HIGHL_COST;
  	else
  	    noinvcurs = 0;
  	goto_cost = GOTO_COST + noinvcurs;
  
  	/*
  	 * Plan how to do the positioning:
  	 * 1. Use CR to move it to column 0, same row.
  	 * 2. Use T_LE to move it a few columns to the left.
  	 * 3. Use NL to move a few lines down, column 0.
  	 * 4. Move a few columns to the right with T_ND or by writing chars.
  	 *
  	 * Don't do this if the cursor went beyond the last column, the cursor
  	 * position is unknown then (some terminals wrap, some don't )
  	 *
  	 * First check if the highlighting attributes allow us to write
  	 * characters to move the cursor to the right.
  	 */
  	if (row >= screen_cur_row && screen_cur_col < Columns)
  	{
  	    /*
  	     * If the cursor is in the same row, bigger col, we can use CR
  	     * or T_LE.
  	     */
  	    bs = NULL;			    /* init for GCC */
  	    attr = screen_attr;
  	    if (row == screen_cur_row && col < screen_cur_col)
  	    {
  		/* "le" is preferred over "bc", because "bc" is obsolete */
  		if (*T_LE)
  		    bs = T_LE;		    /* "cursor left" */
  		else
  		    bs = T_BC;		    /* "backspace character (old) */
  		if (*bs)
  		    cost = (screen_cur_col - col) * (int)STRLEN(bs);
  		else
  		    cost = 999;
  		if (col + 1 < cost)	    /* using CR is less characters */
  		{
  		    plan = PLAN_CR;
  		    wouldbe_col = 0;
  		    cost = 1;		    /* CR is just one character */
  		}
  		else
  		{
  		    plan = PLAN_LE;
  		    wouldbe_col = col;
  		}
  		if (noinvcurs)		    /* will stop highlighting */
  		{
  		    cost += noinvcurs;
  		    attr = 0;
  		}
  	    }
  
  	    /*
  	     * If the cursor is above where we want to be, we can use CR LF.
  	     */
  	    else if (row > screen_cur_row)
  	    {
  		plan = PLAN_NL;
  		wouldbe_col = 0;
  		cost = (row - screen_cur_row) * 2;  /* CR LF */
  		if (noinvcurs)		    /* will stop highlighting */
  		{
  		    cost += noinvcurs;
  		    attr = 0;
  		}
  	    }
  
  	    /*
  	     * If the cursor is in the same row, smaller col, just use write.
  	     */
  	    else
  	    {
  		plan = PLAN_WRITE;
  		wouldbe_col = screen_cur_col;
  		cost = 0;
  	    }
  
  	    /*
  	     * Check if any characters that need to be written have the
  	     * correct attributes.  Also avoid UTF-8 characters.
  	     */
  	    i = col - wouldbe_col;
  	    if (i > 0)
  		cost += i;
  	    if (cost < goto_cost && i > 0)
  	    {
  		/*
  		 * Check if the attributes are correct without additionally
  		 * stopping highlighting.
  		 */
  		p = ScreenAttrs + LineOffset[row] + wouldbe_col;
  		while (i && *p++ == attr)
  		    --i;
  		if (i != 0)
  		{
  		    /*
  		     * Try if it works when highlighting is stopped here.
  		     */
  		    if (*--p == 0)
  		    {
  			cost += noinvcurs;
  			while (i && *p++ == 0)
  			    --i;
  		    }
  		    if (i != 0)
  			cost = 999;	/* different attributes, don't do it */
  		}
  #ifdef FEAT_MBYTE
  		if (enc_utf8)
  		{
  		    /* Don't use an UTF-8 char for positioning, it's slow. */
  		    for (i = wouldbe_col; i < col; ++i)
  			if (ScreenLinesUC[LineOffset[row] + i] != 0)
  			{
  			    cost = 999;
  			    break;
  			}
  		}
  #endif
  	    }
  
  	    /*
  	     * We can do it without term_windgoto()!
  	     */
  	    if (cost < goto_cost)
  	    {
  		if (plan == PLAN_LE)
  		{
  		    if (noinvcurs)
  			screen_stop_highlight();
  		    while (screen_cur_col > col)
  		    {
  			out_str(bs);
  			--screen_cur_col;
  		    }
  		}
  		else if (plan == PLAN_CR)
  		{
  		    if (noinvcurs)
  			screen_stop_highlight();
  		    out_char('\r');
  		    screen_cur_col = 0;
  		}
  		else if (plan == PLAN_NL)
  		{
  		    if (noinvcurs)
  			screen_stop_highlight();
  		    while (screen_cur_row < row)
  		    {
  			out_char('\n');
  			++screen_cur_row;
  		    }
  		    screen_cur_col = 0;
  		}
  
  		i = col - screen_cur_col;
  		if (i > 0)
  		{
  		    /*
  		     * Use cursor-right if it's one character only.  Avoids
  		     * removing a line of pixels from the last bold char, when
  		     * using the bold trick in the GUI.
  		     */
  		    if (T_ND[0] != NUL && T_ND[1] == NUL)
  		    {
  			while (i-- > 0)
  			    out_char(*T_ND);
  		    }
  		    else
  		    {
  			int	off;
  
  			off = LineOffset[row] + screen_cur_col;
  			while (i-- > 0)
  			{
  			    if (ScreenAttrs[off] != screen_attr)
  				screen_stop_highlight();
  #ifdef FEAT_MBYTE
  			    out_flush_check();
  #endif
  			    out_char(ScreenLines[off]);
  #ifdef FEAT_MBYTE
  			    if (enc_dbcs == DBCS_JPNU
  						  && ScreenLines[off] == 0x8e)
  				out_char(ScreenLines2[off]);
  #endif
  			    ++off;
  			}
  		    }
  		}
  	    }
  	}
  	else
  	    cost = 999;
  
  	if (cost >= goto_cost)
  	{
  	    if (noinvcurs)
  		screen_stop_highlight();
  	    if (row == screen_cur_row && (col > screen_cur_col)
  							     && *T_CRI != NUL)
  		term_cursor_right(col - screen_cur_col);
  	    else
  		term_windgoto(row, col);
  	}
  	screen_cur_row = row;
  	screen_cur_col = col;
      }
  }
  
  /*
   * Set cursor to its position in the current window.
   */
      void
  setcursor(void)
  {
      setcursor_mayforce(FALSE);
  }
  
  /*
   * Set cursor to its position in the current window.
   * When "force" is TRUE also when not redrawing.
   */
      void
  setcursor_mayforce(int force)
  {
      if (force || redrawing())
      {
  	validate_cursor();
  	windgoto(W_WINROW(curwin) + curwin->w_wrow,
  		curwin->w_wincol + (
  #ifdef FEAT_RIGHTLEFT
  		/* With 'rightleft' set and the cursor on a double-wide
  		 * character, position it on the leftmost column. */
  		curwin->w_p_rl ? ((int)curwin->w_width - curwin->w_wcol - (
  # ifdef FEAT_MBYTE
  			(has_mbyte
  			   && (*mb_ptr2cells)(ml_get_cursor()) == 2
  			   && vim_isprintc(gchar_cursor())) ? 2 :
  # endif
  			1)) :
  #endif
  							    curwin->w_wcol));
      }
  }
  
  
  /*
   * Insert 'line_count' lines at 'row' in window 'wp'.
   * If 'invalid' is TRUE the wp->w_lines[].wl_lnum is invalidated.
   * If 'mayclear' is TRUE the screen will be cleared if it is faster than
   * scrolling.
   * Returns FAIL if the lines are not inserted, OK for success.
   */
      int
  win_ins_lines(
      win_T	*wp,
      int		row,
      int		line_count,
      int		invalid,
      int		mayclear)
  {
      int		did_delete;
      int		nextrow;
      int		lastrow;
      int		retval;
  
      if (invalid)
  	wp->w_lines_valid = 0;
  
      if (wp->w_height < 5)
  	return FAIL;
  
      if (line_count > wp->w_height - row)
  	line_count = wp->w_height - row;
  
      retval = win_do_lines(wp, row, line_count, mayclear, FALSE, 0);
      if (retval != MAYBE)
  	return retval;
  
      /*
       * If there is a next window or a status line, we first try to delete the
       * lines at the bottom to avoid messing what is after the window.
       * If this fails and there are following windows, don't do anything to avoid
       * messing up those windows, better just redraw.
       */
      did_delete = FALSE;
      if (wp->w_next != NULL || wp->w_status_height)
      {
  	if (screen_del_lines(0, W_WINROW(wp) + wp->w_height - line_count,
  				  line_count, (int)Rows, FALSE, 0, NULL) == OK)
  	    did_delete = TRUE;
  	else if (wp->w_next)
  	    return FAIL;
      }
      /*
       * if no lines deleted, blank the lines that will end up below the window
       */
      if (!did_delete)
      {
  	wp->w_redr_status = TRUE;
  	redraw_cmdline = TRUE;
  	nextrow = W_WINROW(wp) + wp->w_height + wp->w_status_height;
  	lastrow = nextrow + line_count;
  	if (lastrow > Rows)
  	    lastrow = Rows;
  	screen_fill(nextrow - line_count, lastrow - line_count,
  		  wp->w_wincol, (int)W_ENDCOL(wp),
  		  ' ', ' ', 0);
      }
  
      if (screen_ins_lines(0, W_WINROW(wp) + row, line_count, (int)Rows, 0, NULL)
  								      == FAIL)
      {
  	    /* deletion will have messed up other windows */
  	if (did_delete)
  	{
  	    wp->w_redr_status = TRUE;
  	    win_rest_invalid(W_NEXT(wp));
  	}
  	return FAIL;
      }
  
      return OK;
  }
  
  /*
   * Delete "line_count" window lines at "row" in window "wp".
   * If "invalid" is TRUE curwin->w_lines[] is invalidated.
   * If "mayclear" is TRUE the screen will be cleared if it is faster than
   * scrolling
   * Return OK for success, FAIL if the lines are not deleted.
   */
      int
  win_del_lines(
      win_T	*wp,
      int		row,
      int		line_count,
      int		invalid,
      int		mayclear,
      int		clear_attr)	    /* for clearing lines */
  {
      int		retval;
  
      if (invalid)
  	wp->w_lines_valid = 0;
  
      if (line_count > wp->w_height - row)
  	line_count = wp->w_height - row;
  
      retval = win_do_lines(wp, row, line_count, mayclear, TRUE, clear_attr);
      if (retval != MAYBE)
  	return retval;
  
      if (screen_del_lines(0, W_WINROW(wp) + row, line_count,
  				   (int)Rows, FALSE, clear_attr, NULL) == FAIL)
  	return FAIL;
  
      /*
       * If there are windows or status lines below, try to put them at the
       * correct place. If we can't do that, they have to be redrawn.
       */
      if (wp->w_next || wp->w_status_height || cmdline_row < Rows - 1)
      {
  	if (screen_ins_lines(0, W_WINROW(wp) + wp->w_height - line_count,
  			      line_count, (int)Rows, clear_attr, NULL) == FAIL)
  	{
  	    wp->w_redr_status = TRUE;
  	    win_rest_invalid(wp->w_next);
  	}
      }
      /*
       * If this is the last window and there is no status line, redraw the
       * command line later.
       */
      else
  	redraw_cmdline = TRUE;
      return OK;
  }
  
  /*
   * Common code for win_ins_lines() and win_del_lines().
   * Returns OK or FAIL when the work has been done.
   * Returns MAYBE when not finished yet.
   */
      static int
  win_do_lines(
      win_T	*wp,
      int		row,
      int		line_count,
      int		mayclear,
      int		del,
      int		clear_attr)
  {
      int		retval;
  
      if (!redrawing() || line_count <= 0)
  	return FAIL;
  
      /* When inserting lines would result in loss of command output, just redraw
       * the lines. */
      if (no_win_do_lines_ins && !del)
  	return FAIL;
  
      /* only a few lines left: redraw is faster */
      if (mayclear && Rows - line_count < 5 && wp->w_width == Columns)
      {
  	if (!no_win_do_lines_ins)
  	    screenclear();	    /* will set wp->w_lines_valid to 0 */
  	return FAIL;
      }
  
      /*
       * Delete all remaining lines
       */
      if (row + line_count >= wp->w_height)
      {
  	screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + wp->w_height,
  		wp->w_wincol, (int)W_ENDCOL(wp),
  		' ', ' ', 0);
  	return OK;
      }
  
      /*
       * When scrolling, the message on the command line should be cleared,
       * otherwise it will stay there forever.
       * Don't do this when avoiding to insert lines.
       */
      if (!no_win_do_lines_ins)
  	clear_cmdline = TRUE;
  
      /*
       * If the terminal can set a scroll region, use that.
       * Always do this in a vertically split window.  This will redraw from
       * ScreenLines[] when t_CV isn't defined.  That's faster than using
       * win_line().
       * Don't use a scroll region when we are going to redraw the text, writing
       * a character in the lower right corner of the scroll region may cause a
       * scroll-up .
       */
      if (scroll_region || wp->w_width != Columns)
      {
  	if (scroll_region && (wp->w_width == Columns || *T_CSV != NUL))
  	    scroll_region_set(wp, row);
  	if (del)
  	    retval = screen_del_lines(W_WINROW(wp) + row, 0, line_count,
  				    wp->w_height - row, FALSE, clear_attr, wp);
  	else
  	    retval = screen_ins_lines(W_WINROW(wp) + row, 0, line_count,
  					   wp->w_height - row, clear_attr, wp);
  	if (scroll_region && (wp->w_width == Columns || *T_CSV != NUL))
  	    scroll_region_reset();
  	return retval;
      }
  
      if (wp->w_next != NULL && p_tf) /* don't delete/insert on fast terminal */
  	return FAIL;
  
      return MAYBE;
  }
  
  /*
   * window 'wp' and everything after it is messed up, mark it for redraw
   */
      static void
  win_rest_invalid(win_T *wp)
  {
      while (wp != NULL)
      {
  	redraw_win_later(wp, NOT_VALID);
  	wp->w_redr_status = TRUE;
  	wp = wp->w_next;
      }
      redraw_cmdline = TRUE;
  }
  
  /*
   * The rest of the routines in this file perform screen manipulations. The
   * given operation is performed physically on the screen. The corresponding
   * change is also made to the internal screen image. In this way, the editor
   * anticipates the effect of editing changes on the appearance of the screen.
   * That way, when we call screenupdate a complete redraw isn't usually
   * necessary. Another advantage is that we can keep adding code to anticipate
   * screen changes, and in the meantime, everything still works.
   */
  
  /*
   * types for inserting or deleting lines
   */
  #define USE_T_CAL   1
  #define USE_T_CDL   2
  #define USE_T_AL    3
  #define USE_T_CE    4
  #define USE_T_DL    5
  #define USE_T_SR    6
  #define USE_NL	    7
  #define USE_T_CD    8
  #define USE_REDRAW  9
  
  /*
   * insert lines on the screen and update ScreenLines[]
   * 'end' is the line after the scrolled part. Normally it is Rows.
   * When scrolling region used 'off' is the offset from the top for the region.
   * 'row' and 'end' are relative to the start of the region.
   *
   * return FAIL for failure, OK for success.
   */
      int
  screen_ins_lines(
      int		off,
      int		row,
      int		line_count,
      int		end,
      int		clear_attr,
      win_T	*wp)	    /* NULL or window to use width from */
  {
      int		i;
      int		j;
      unsigned	temp;
      int		cursor_row;
      int		type;
      int		result_empty;
      int		can_ce = can_clear(T_CE);
  
      /*
       * FAIL if
       * - there is no valid screen
       * - the screen has to be redrawn completely
       * - the line count is less than one
       * - the line count is more than 'ttyscroll'
       * - redrawing for a callback and there is a modeless selection
       */
       if (!screen_valid(TRUE) || line_count <= 0 || line_count > p_ttyscroll
  #ifdef FEAT_CLIPBOARD
  	     || (clip_star.state != SELECT_CLEARED
  						 && redrawing_for_callback > 0)
  #endif
  	     )
  	return FAIL;
  
      /*
       * There are seven ways to insert lines:
       * 0. When in a vertically split window and t_CV isn't set, redraw the
       *    characters from ScreenLines[].
       * 1. Use T_CD (clear to end of display) if it exists and the result of
       *	  the insert is just empty lines
       * 2. Use T_CAL (insert multiple lines) if it exists and T_AL is not
       *	  present or line_count > 1. It looks better if we do all the inserts
       *	  at once.
       * 3. Use T_CDL (delete multiple lines) if it exists and the result of the
       *	  insert is just empty lines and T_CE is not present or line_count >
       *	  1.
       * 4. Use T_AL (insert line) if it exists.
       * 5. Use T_CE (erase line) if it exists and the result of the insert is
       *	  just empty lines.
       * 6. Use T_DL (delete line) if it exists and the result of the insert is
       *	  just empty lines.
       * 7. Use T_SR (scroll reverse) if it exists and inserting at row 0 and
       *	  the 'da' flag is not set or we have clear line capability.
       * 8. redraw the characters from ScreenLines[].
       *
       * Careful: In a hpterm scroll reverse doesn't work as expected, it moves
       * the scrollbar for the window. It does have insert line, use that if it
       * exists.
       */
      result_empty = (row + line_count >= end);
      if (wp != NULL && wp->w_width != Columns && *T_CSV == NUL)
  	type = USE_REDRAW;
      else if (can_clear(T_CD) && result_empty)
  	type = USE_T_CD;
      else if (*T_CAL != NUL && (line_count > 1 || *T_AL == NUL))
  	type = USE_T_CAL;
      else if (*T_CDL != NUL && result_empty && (line_count > 1 || !can_ce))
  	type = USE_T_CDL;
      else if (*T_AL != NUL)
  	type = USE_T_AL;
      else if (can_ce && result_empty)
  	type = USE_T_CE;
      else if (*T_DL != NUL && result_empty)
  	type = USE_T_DL;
      else if (*T_SR != NUL && row == 0 && (*T_DA == NUL || can_ce))
  	type = USE_T_SR;
      else
  	return FAIL;
  
      /*
       * For clearing the lines screen_del_lines() is used. This will also take
       * care of t_db if necessary.
       */
      if (type == USE_T_CD || type == USE_T_CDL ||
  					 type == USE_T_CE || type == USE_T_DL)
  	return screen_del_lines(off, row, line_count, end, FALSE, 0, wp);
  
      /*
       * If text is retained below the screen, first clear or delete as many
       * lines at the bottom of the window as are about to be inserted so that
       * the deleted lines won't later surface during a screen_del_lines.
       */
      if (*T_DB)
  	screen_del_lines(off, end - line_count, line_count, end, FALSE, 0, wp);
  
  #ifdef FEAT_CLIPBOARD
      /* Remove a modeless selection when inserting lines halfway the screen
       * or not the full width of the screen. */
      if (off + row > 0 || (wp != NULL && wp->w_width != Columns))
  	clip_clear_selection(&clip_star);
      else
  	clip_scroll_selection(-line_count);
  #endif
  
  #ifdef FEAT_GUI
      /* Don't update the GUI cursor here, ScreenLines[] is invalid until the
       * scrolling is actually carried out. */
      gui_dont_update_cursor(row + off <= gui.cursor_row);
  #endif
  
      if (*T_CCS != NUL)	   /* cursor relative to region */
  	cursor_row = row;
      else
  	cursor_row = row + off;
  
      /*
       * Shift LineOffset[] line_count down to reflect the inserted lines.
       * Clear the inserted lines in ScreenLines[].
       */
      row += off;
      end += off;
      for (i = 0; i < line_count; ++i)
      {
  	if (wp != NULL && wp->w_width != Columns)
  	{
  	    /* need to copy part of a line */
  	    j = end - 1 - i;
  	    while ((j -= line_count) >= row)
  		linecopy(j + line_count, j, wp);
  	    j += line_count;
  	    if (can_clear((char_u *)" "))
  		lineclear(LineOffset[j] + wp->w_wincol, wp->w_width,
  								   clear_attr);
  	    else
  		lineinvalid(LineOffset[j] + wp->w_wincol, wp->w_width);
  	    LineWraps[j] = FALSE;
  	}
  	else
  	{
  	    j = end - 1 - i;
  	    temp = LineOffset[j];
  	    while ((j -= line_count) >= row)
  	    {
  		LineOffset[j + line_count] = LineOffset[j];
  		LineWraps[j + line_count] = LineWraps[j];
  	    }
  	    LineOffset[j + line_count] = temp;
  	    LineWraps[j + line_count] = FALSE;
  	    if (can_clear((char_u *)" "))
  		lineclear(temp, (int)Columns, clear_attr);
  	    else
  		lineinvalid(temp, (int)Columns);
  	}
      }
  
      screen_stop_highlight();
      windgoto(cursor_row, 0);
      if (clear_attr != 0)
  	screen_start_highlight(clear_attr);
  
      /* redraw the characters */
      if (type == USE_REDRAW)
  	redraw_block(row, end, wp);
      else if (type == USE_T_CAL)
      {
  	term_append_lines(line_count);
  	screen_start();		/* don't know where cursor is now */
      }
      else
      {
  	for (i = 0; i < line_count; i++)
  	{
  	    if (type == USE_T_AL)
  	    {
  		if (i && cursor_row != 0)
  		    windgoto(cursor_row, 0);
  		out_str(T_AL);
  	    }
  	    else  /* type == USE_T_SR */
  		out_str(T_SR);
  	    screen_start();	    /* don't know where cursor is now */
  	}
      }
  
      /*
       * With scroll-reverse and 'da' flag set we need to clear the lines that
       * have been scrolled down into the region.
       */
      if (type == USE_T_SR && *T_DA)
      {
  	for (i = 0; i < line_count; ++i)
  	{
  	    windgoto(off + i, 0);
  	    out_str(T_CE);
  	    screen_start();	    /* don't know where cursor is now */
  	}
      }
  
  #ifdef FEAT_GUI
      gui_can_update_cursor();
      if (gui.in_use)
  	out_flush();	/* always flush after a scroll */
  #endif
      return OK;
  }
  
  /*
   * Delete lines on the screen and update ScreenLines[].
   * "end" is the line after the scrolled part. Normally it is Rows.
   * When scrolling region used "off" is the offset from the top for the region.
   * "row" and "end" are relative to the start of the region.
   *
   * Return OK for success, FAIL if the lines are not deleted.
   */
      int
  screen_del_lines(
      int		off,
      int		row,
      int		line_count,
      int		end,
      int		force,		/* even when line_count > p_ttyscroll */
      int		clear_attr,	/* used for clearing lines */
      win_T	*wp UNUSED)	/* NULL or window to use width from */
  {
      int		j;
      int		i;
      unsigned	temp;
      int		cursor_row;
      int		cursor_end;
      int		result_empty;	/* result is empty until end of region */
      int		can_delete;	/* deleting line codes can be used */
      int		type;
  
      /*
       * FAIL if
       * - there is no valid screen
       * - the screen has to be redrawn completely
       * - the line count is less than one
       * - the line count is more than 'ttyscroll'
       * - redrawing for a callback and there is a modeless selection
       */
      if (!screen_valid(TRUE) || line_count <= 0
  					|| (!force && line_count > p_ttyscroll)
  #ifdef FEAT_CLIPBOARD
  	     || (clip_star.state != SELECT_CLEARED
  						 && redrawing_for_callback > 0)
  #endif
         )
  	return FAIL;
  
      /*
       * Check if the rest of the current region will become empty.
       */
      result_empty = row + line_count >= end;
  
      /*
       * We can delete lines only when 'db' flag not set or when 'ce' option
       * available.
       */
      can_delete = (*T_DB == NUL || can_clear(T_CE));
  
      /*
       * There are six ways to delete lines:
       * 0. When in a vertically split window and t_CV isn't set, redraw the
       *    characters from ScreenLines[].
       * 1. Use T_CD if it exists and the result is empty.
       * 2. Use newlines if row == 0 and count == 1 or T_CDL does not exist.
       * 3. Use T_CDL (delete multiple lines) if it exists and line_count > 1 or
       *	  none of the other ways work.
       * 4. Use T_CE (erase line) if the result is empty.
       * 5. Use T_DL (delete line) if it exists.
       * 6. redraw the characters from ScreenLines[].
       */
      if (wp != NULL && wp->w_width != Columns && *T_CSV == NUL)
  	type = USE_REDRAW;
      else if (can_clear(T_CD) && result_empty)
  	type = USE_T_CD;
  #if defined(__BEOS__) && defined(BEOS_DR8)
      /*
       * USE_NL does not seem to work in Terminal of DR8 so we set T_DB="" in
       * its internal termcap... this works okay for tests which test *T_DB !=
       * NUL.  It has the disadvantage that the user cannot use any :set t_*
       * command to get T_DB (back) to empty_option, only :set term=... will do
       * the trick...
       * Anyway, this hack will hopefully go away with the next OS release.
       * (Olaf Seibert)
       */
      else if (row == 0 && T_DB == empty_option
  					&& (line_count == 1 || *T_CDL == NUL))
  #else
      else if (row == 0 && (
  #ifndef AMIGA
  	/* On the Amiga, somehow '\n' on the last line doesn't always scroll
  	 * up, so use delete-line command */
  			    line_count == 1 ||
  #endif
  						*T_CDL == NUL))
  #endif
  	type = USE_NL;
      else if (*T_CDL != NUL && line_count > 1 && can_delete)
  	type = USE_T_CDL;
      else if (can_clear(T_CE) && result_empty
  	    && (wp == NULL || wp->w_width == Columns))
  	type = USE_T_CE;
      else if (*T_DL != NUL && can_delete)
  	type = USE_T_DL;
      else if (*T_CDL != NUL && can_delete)
  	type = USE_T_CDL;
      else
  	return FAIL;
  
  #ifdef FEAT_CLIPBOARD
      /* Remove a modeless selection when deleting lines halfway the screen or
       * not the full width of the screen. */
      if (off + row > 0 || (wp != NULL && wp->w_width != Columns))
  	clip_clear_selection(&clip_star);
      else
  	clip_scroll_selection(line_count);
  #endif
  
  #ifdef FEAT_GUI
      /* Don't update the GUI cursor here, ScreenLines[] is invalid until the
       * scrolling is actually carried out. */
      gui_dont_update_cursor(gui.cursor_row >= row + off
  						&& gui.cursor_row < end + off);
  #endif
  
      if (*T_CCS != NUL)	    /* cursor relative to region */
      {
  	cursor_row = row;
  	cursor_end = end;
      }
      else
      {
  	cursor_row = row + off;
  	cursor_end = end + off;
      }
  
      /*
       * Now shift LineOffset[] line_count up to reflect the deleted lines.
       * Clear the inserted lines in ScreenLines[].
       */
      row += off;
      end += off;
      for (i = 0; i < line_count; ++i)
      {
  	if (wp != NULL && wp->w_width != Columns)
  	{
  	    /* need to copy part of a line */
  	    j = row + i;
  	    while ((j += line_count) <= end - 1)
  		linecopy(j - line_count, j, wp);
  	    j -= line_count;
  	    if (can_clear((char_u *)" "))
  		lineclear(LineOffset[j] + wp->w_wincol, wp->w_width,
  								   clear_attr);
  	    else
  		lineinvalid(LineOffset[j] + wp->w_wincol, wp->w_width);
  	    LineWraps[j] = FALSE;
  	}
  	else
  	{
  	    /* whole width, moving the line pointers is faster */
  	    j = row + i;
  	    temp = LineOffset[j];
  	    while ((j += line_count) <= end - 1)
  	    {
  		LineOffset[j - line_count] = LineOffset[j];
  		LineWraps[j - line_count] = LineWraps[j];
  	    }
  	    LineOffset[j - line_count] = temp;
  	    LineWraps[j - line_count] = FALSE;
  	    if (can_clear((char_u *)" "))
  		lineclear(temp, (int)Columns, clear_attr);
  	    else
  		lineinvalid(temp, (int)Columns);
  	}
      }
  
      if (screen_attr != clear_attr)
  	screen_stop_highlight();
      if (clear_attr != 0)
  	screen_start_highlight(clear_attr);
  
      /* redraw the characters */
      if (type == USE_REDRAW)
  	redraw_block(row, end, wp);
      else if (type == USE_T_CD)	/* delete the lines */
      {
  	windgoto(cursor_row, 0);
  	out_str(T_CD);
  	screen_start();			/* don't know where cursor is now */
      }
      else if (type == USE_T_CDL)
      {
  	windgoto(cursor_row, 0);
  	term_delete_lines(line_count);
  	screen_start();			/* don't know where cursor is now */
      }
      /*
       * Deleting lines at top of the screen or scroll region: Just scroll
       * the whole screen (scroll region) up by outputting newlines on the
       * last line.
       */
      else if (type == USE_NL)
      {
  	windgoto(cursor_end - 1, 0);
  	for (i = line_count; --i >= 0; )
  	    out_char('\n');		/* cursor will remain on same line */
      }
      else
      {
  	for (i = line_count; --i >= 0; )
  	{
  	    if (type == USE_T_DL)
  	    {
  		windgoto(cursor_row, 0);
  		out_str(T_DL);		/* delete a line */
  	    }
  	    else /* type == USE_T_CE */
  	    {
  		windgoto(cursor_row + i, 0);
  		out_str(T_CE);		/* erase a line */
  	    }
  	    screen_start();		/* don't know where cursor is now */
  	}
      }
  
      /*
       * If the 'db' flag is set, we need to clear the lines that have been
       * scrolled up at the bottom of the region.
       */
      if (*T_DB && (type == USE_T_DL || type == USE_T_CDL))
      {
  	for (i = line_count; i > 0; --i)
  	{
  	    windgoto(cursor_end - i, 0);
  	    out_str(T_CE);		/* erase a line */
  	    screen_start();		/* don't know where cursor is now */
  	}
      }
  
  #ifdef FEAT_GUI
      gui_can_update_cursor();
      if (gui.in_use)
  	out_flush();	/* always flush after a scroll */
  #endif
  
      return OK;
  }
  
  /*
   * Show the current mode and ruler.
   *
   * If clear_cmdline is TRUE, clear the rest of the cmdline.
   * If clear_cmdline is FALSE there may be a message there that needs to be
   * cleared only if a mode is shown.
   * Return the length of the message (0 if no message).
   */
      int
  showmode(void)
  {
      int		need_clear;
      int		length = 0;
      int		do_mode;
      int		attr;
      int		nwr_save;
  #ifdef FEAT_INS_EXPAND
      int		sub_attr;
  #endif
  
      do_mode = ((p_smd && msg_silent == 0)
  	    && ((State & INSERT)
  		|| restart_edit
  		|| VIsual_active));
      if (do_mode || Recording)
      {
  	/*
  	 * Don't show mode right now, when not redrawing or inside a mapping.
  	 * Call char_avail() only when we are going to show something, because
  	 * it takes a bit of time.
  	 */
  	if (!redrawing() || (char_avail() && !KeyTyped) || msg_silent != 0)
  	{
  	    redraw_cmdline = TRUE;		/* show mode later */
  	    return 0;
  	}
  
  	nwr_save = need_wait_return;
  
  	/* wait a bit before overwriting an important message */
  	check_for_delay(FALSE);
  
  	/* if the cmdline is more than one line high, erase top lines */
  	need_clear = clear_cmdline;
  	if (clear_cmdline && cmdline_row < Rows - 1)
  	    msg_clr_cmdline();			/* will reset clear_cmdline */
  
  	/* Position on the last line in the window, column 0 */
  	msg_pos_mode();
  	cursor_off();
  	attr = HL_ATTR(HLF_CM);			/* Highlight mode */
  	if (do_mode)
  	{
  	    MSG_PUTS_ATTR("--", attr);
  #if defined(FEAT_XIM)
  	    if (
  # ifdef FEAT_GUI_GTK
  		    preedit_get_status()
  # else
  		    im_get_status()
  # endif
  	       )
  # ifdef FEAT_GUI_GTK /* most of the time, it's not XIM being used */
  		MSG_PUTS_ATTR(" IM", attr);
  # else
  		MSG_PUTS_ATTR(" XIM", attr);
  # endif
  #endif
  #if defined(FEAT_HANGULIN) && defined(FEAT_GUI)
  	    if (gui.in_use)
  	    {
  		if (hangul_input_state_get())
  		{
  		    /* HANGUL */
  		    if (enc_utf8)
  			MSG_PUTS_ATTR(" \355\225\234\352\270\200", attr);
  		    else
  			MSG_PUTS_ATTR(" \307\321\261\333", attr);
  		}
  	    }
  #endif
  #ifdef FEAT_INS_EXPAND
  	    /* CTRL-X in Insert mode */
  	    if (edit_submode != NULL && !shortmess(SHM_COMPLETIONMENU))
  	    {
  		/* These messages can get long, avoid a wrap in a narrow
  		 * window.  Prefer showing edit_submode_extra. */
  		length = (Rows - msg_row) * Columns - 3;
  		if (edit_submode_extra != NULL)
  		    length -= vim_strsize(edit_submode_extra);
  		if (length > 0)
  		{
  		    if (edit_submode_pre != NULL)
  			length -= vim_strsize(edit_submode_pre);
  		    if (length - vim_strsize(edit_submode) > 0)
  		    {
  			if (edit_submode_pre != NULL)
  			    msg_puts_attr(edit_submode_pre, attr);
  			msg_puts_attr(edit_submode, attr);
  		    }
  		    if (edit_submode_extra != NULL)
  		    {
  			MSG_PUTS_ATTR(" ", attr);  /* add a space in between */
  			if ((int)edit_submode_highl < (int)HLF_COUNT)
  			    sub_attr = HL_ATTR(edit_submode_highl);
  			else
  			    sub_attr = attr;
  			msg_puts_attr(edit_submode_extra, sub_attr);
  		    }
  		}
  	    }
  	    else
  #endif
  	    {
  #ifdef FEAT_VREPLACE
  		if (State & VREPLACE_FLAG)
  		    MSG_PUTS_ATTR(_(" VREPLACE"), attr);
  		else
  #endif
  		    if (State & REPLACE_FLAG)
  		    MSG_PUTS_ATTR(_(" REPLACE"), attr);
  		else if (State & INSERT)
  		{
  #ifdef FEAT_RIGHTLEFT
  		    if (p_ri)
  			MSG_PUTS_ATTR(_(" REVERSE"), attr);
  #endif
  		    MSG_PUTS_ATTR(_(" INSERT"), attr);
  		}
  		else if (restart_edit == 'I')
  		    MSG_PUTS_ATTR(_(" (insert)"), attr);
  		else if (restart_edit == 'R')
  		    MSG_PUTS_ATTR(_(" (replace)"), attr);
  		else if (restart_edit == 'V')
  		    MSG_PUTS_ATTR(_(" (vreplace)"), attr);
  #ifdef FEAT_RIGHTLEFT
  		if (p_hkmap)
  		    MSG_PUTS_ATTR(_(" Hebrew"), attr);
  # ifdef FEAT_FKMAP
  		if (p_fkmap)
  		    MSG_PUTS_ATTR(farsi_text_5, attr);
  # endif
  #endif
  #ifdef FEAT_KEYMAP
  		if (State & LANGMAP)
  		{
  # ifdef FEAT_ARABIC
  		    if (curwin->w_p_arab)
  			MSG_PUTS_ATTR(_(" Arabic"), attr);
  		    else
  # endif
  			if (get_keymap_str(curwin, (char_u *)" (%s)",
  							   NameBuff, MAXPATHL))
  			    MSG_PUTS_ATTR(NameBuff, attr);
  		}
  #endif
  		if ((State & INSERT) && p_paste)
  		    MSG_PUTS_ATTR(_(" (paste)"), attr);
  
  		if (VIsual_active)
  		{
  		    char *p;
  
  		    /* Don't concatenate separate words to avoid translation
  		     * problems. */
  		    switch ((VIsual_select ? 4 : 0)
  			    + (VIsual_mode == Ctrl_V) * 2
  			    + (VIsual_mode == 'V'))
  		    {
  			case 0:	p = N_(" VISUAL"); break;
  			case 1: p = N_(" VISUAL LINE"); break;
  			case 2: p = N_(" VISUAL BLOCK"); break;
  			case 4: p = N_(" SELECT"); break;
  			case 5: p = N_(" SELECT LINE"); break;
  			default: p = N_(" SELECT BLOCK"); break;
  		    }
  		    MSG_PUTS_ATTR(_(p), attr);
  		}
  		MSG_PUTS_ATTR(" --", attr);
  	    }
  
  	    need_clear = TRUE;
  	}
  	if (Recording
  #ifdef FEAT_INS_EXPAND
  		&& edit_submode == NULL	    /* otherwise it gets too long */
  #endif
  		)
  	{
  	    recording_mode(attr);
  	    need_clear = TRUE;
  	}
  
  	mode_displayed = TRUE;
  	if (need_clear || clear_cmdline)
  	    msg_clr_eos();
  	msg_didout = FALSE;		/* overwrite this message */
  	length = msg_col;
  	msg_col = 0;
  	need_wait_return = nwr_save;	/* never ask for hit-return for this */
      }
      else if (clear_cmdline && msg_silent == 0)
  	/* Clear the whole command line.  Will reset "clear_cmdline". */
  	msg_clr_cmdline();
  
  #ifdef FEAT_CMDL_INFO
      /* In Visual mode the size of the selected area must be redrawn. */
      if (VIsual_active)
  	clear_showcmd();
  
      /* If the last window has no status line, the ruler is after the mode
       * message and must be redrawn */
      if (redrawing() && lastwin->w_status_height == 0)
  	win_redr_ruler(lastwin, TRUE);
  #endif
      redraw_cmdline = FALSE;
      clear_cmdline = FALSE;
  
      return length;
  }
  
  /*
   * Position for a mode message.
   */
      static void
  msg_pos_mode(void)
  {
      msg_col = 0;
      msg_row = Rows - 1;
  }
  
  /*
   * Delete mode message.  Used when ESC is typed which is expected to end
   * Insert mode (but Insert mode didn't end yet!).
   * Caller should check "mode_displayed".
   */
      void
  unshowmode(int force)
  {
      /*
       * Don't delete it right now, when not redrawing or inside a mapping.
       */
      if (!redrawing() || (!force && char_avail() && !KeyTyped))
  	redraw_cmdline = TRUE;		/* delete mode later */
      else
  	clearmode();
  }
  
  /*
   * Clear the mode message.
   */
      void
  clearmode(void)
  {
      msg_pos_mode();
      if (Recording)
  	recording_mode(HL_ATTR(HLF_CM));
      msg_clr_eos();
  }
  
      static void
  recording_mode(int attr)
  {
      MSG_PUTS_ATTR(_("recording"), attr);
      if (!shortmess(SHM_RECORDING))
      {
  	char_u s[4];
  	sprintf((char *)s, " @%c", Recording);
  	MSG_PUTS_ATTR(s, attr);
      }
  }
  
  /*
   * Draw the tab pages line at the top of the Vim window.
   */
      static void
  draw_tabline(void)
  {
      int		tabcount = 0;
      tabpage_T	*tp;
      int		tabwidth;
      int		col = 0;
      int		scol = 0;
      int		attr;
      win_T	*wp;
      win_T	*cwp;
      int		wincount;
      int		modified;
      int		c;
      int		len;
      int		attr_sel = HL_ATTR(HLF_TPS);
      int		attr_nosel = HL_ATTR(HLF_TP);
      int		attr_fill = HL_ATTR(HLF_TPF);
      char_u	*p;
      int		room;
      int		use_sep_chars = (t_colors < 8
  #ifdef FEAT_GUI
  					    && !gui.in_use
  #endif
  #ifdef FEAT_TERMGUICOLORS
  					    && !p_tgc
  #endif
  					    );
  
      if (ScreenLines == NULL)
  	return;
      redraw_tabline = FALSE;
  
  #ifdef FEAT_GUI_TABLINE
      /* Take care of a GUI tabline. */
      if (gui_use_tabline())
      {
  	gui_update_tabline();
  	return;
      }
  #endif
  
      if (tabline_height() < 1)
  	return;
  
  #if defined(FEAT_STL_OPT)
  
      /* Init TabPageIdxs[] to zero: Clicking outside of tabs has no effect. */
      for (scol = 0; scol < Columns; ++scol)
  	TabPageIdxs[scol] = 0;
  
      /* Use the 'tabline' option if it's set. */
      if (*p_tal != NUL)
      {
  	int	saved_did_emsg = did_emsg;
  
  	/* Check for an error.  If there is one we would loop in redrawing the
  	 * screen.  Avoid that by making 'tabline' empty. */
  	did_emsg = FALSE;
  	win_redr_custom(NULL, FALSE);
  	if (did_emsg)
  	    set_string_option_direct((char_u *)"tabline", -1,
  					   (char_u *)"", OPT_FREE, SID_ERROR);
  	did_emsg |= saved_did_emsg;
      }
      else
  #endif
      {
  	FOR_ALL_TABPAGES(tp)
  	    ++tabcount;
  
  	tabwidth = (Columns - 1 + tabcount / 2) / tabcount;
  	if (tabwidth < 6)
  	    tabwidth = 6;
  
  	attr = attr_nosel;
  	tabcount = 0;
  	scol = 0;
  	for (tp = first_tabpage; tp != NULL && col < Columns - 4;
  							     tp = tp->tp_next)
  	{
  	    scol = col;
  
  	    if (tp->tp_topframe == topframe)
  		attr = attr_sel;
  	    if (use_sep_chars && col > 0)
  		screen_putchar('|', 0, col++, attr);
  
  	    if (tp->tp_topframe != topframe)
  		attr = attr_nosel;
  
  	    screen_putchar(' ', 0, col++, attr);
  
  	    if (tp == curtab)
  	    {
  		cwp = curwin;
  		wp = firstwin;
  	    }
  	    else
  	    {
  		cwp = tp->tp_curwin;
  		wp = tp->tp_firstwin;
  	    }
  
  	    modified = FALSE;
  	    for (wincount = 0; wp != NULL; wp = wp->w_next, ++wincount)
  		if (bufIsChanged(wp->w_buffer))
  		    modified = TRUE;
  	    if (modified || wincount > 1)
  	    {
  		if (wincount > 1)
  		{
  		    vim_snprintf((char *)NameBuff, MAXPATHL, "%d", wincount);
  		    len = (int)STRLEN(NameBuff);
  		    if (col + len >= Columns - 3)
  			break;
  		    screen_puts_len(NameBuff, len, 0, col,
  #if defined(FEAT_SYN_HL)
  					 hl_combine_attr(attr, HL_ATTR(HLF_T))
  #else
  					 attr
  #endif
  					       );
  		    col += len;
  		}
  		if (modified)
  		    screen_puts_len((char_u *)"+", 1, 0, col++, attr);
  		screen_putchar(' ', 0, col++, attr);
  	    }
  
  	    room = scol - col + tabwidth - 1;
  	    if (room > 0)
  	    {
  		/* Get buffer name in NameBuff[] */
  		get_trans_bufname(cwp->w_buffer);
  		shorten_dir(NameBuff);
  		len = vim_strsize(NameBuff);
  		p = NameBuff;
  #ifdef FEAT_MBYTE
  		if (has_mbyte)
  		    while (len > room)
  		    {
  			len -= ptr2cells(p);
  			MB_PTR_ADV(p);
  		    }
  		else
  #endif
  		    if (len > room)
  		{
  		    p += len - room;
  		    len = room;
  		}
  		if (len > Columns - col - 1)
  		    len = Columns - col - 1;
  
  		screen_puts_len(p, (int)STRLEN(p), 0, col, attr);
  		col += len;
  	    }
  	    screen_putchar(' ', 0, col++, attr);
  
  	    /* Store the tab page number in TabPageIdxs[], so that
  	     * jump_to_mouse() knows where each one is. */
  	    ++tabcount;
  	    while (scol < col)
  		TabPageIdxs[scol++] = tabcount;
  	}
  
  	if (use_sep_chars)
  	    c = '_';
  	else
  	    c = ' ';
  	screen_fill(0, 1, col, (int)Columns, c, c, attr_fill);
  
  	/* Put an "X" for closing the current tab if there are several. */
  	if (first_tabpage->tp_next != NULL)
  	{
  	    screen_putchar('X', 0, (int)Columns - 1, attr_nosel);
  	    TabPageIdxs[Columns - 1] = -999;
  	}
      }
  
      /* Reset the flag here again, in case evaluating 'tabline' causes it to be
       * set. */
      redraw_tabline = FALSE;
  }
  
  /*
   * Get buffer name for "buf" into NameBuff[].
   * Takes care of special buffer names and translates special characters.
   */
      void
  get_trans_bufname(buf_T *buf)
  {
      if (buf_spname(buf) != NULL)
  	vim_strncpy(NameBuff, buf_spname(buf), MAXPATHL - 1);
      else
  	home_replace(buf, buf->b_fname, NameBuff, MAXPATHL, TRUE);
      trans_characters(NameBuff, MAXPATHL);
  }
  
  /*
   * Get the character to use in a status line.  Get its attributes in "*attr".
   */
      static int
  fillchar_status(int *attr, win_T *wp)
  {
      int fill;
  
  #ifdef FEAT_TERMINAL
      if (bt_terminal(wp->w_buffer))
      {
  	if (wp == curwin)
  	{
  	    *attr = HL_ATTR(HLF_ST);
  	    fill = fill_stl;
  	}
  	else
  	{
  	    *attr = HL_ATTR(HLF_STNC);
  	    fill = fill_stlnc;
  	}
      }
      else
  #endif
      if (wp == curwin)
      {
  	*attr = HL_ATTR(HLF_S);
  	fill = fill_stl;
      }
      else
      {
  	*attr = HL_ATTR(HLF_SNC);
  	fill = fill_stlnc;
      }
      /* Use fill when there is highlighting, and highlighting of current
       * window differs, or the fillchars differ, or this is not the
       * current window */
      if (*attr != 0 && ((HL_ATTR(HLF_S) != HL_ATTR(HLF_SNC)
  			|| wp != curwin || ONE_WINDOW)
  		    || (fill_stl != fill_stlnc)))
  	return fill;
      if (wp == curwin)
  	return '^';
      return '=';
  }
  
  /*
   * Get the character to use in a separator between vertically split windows.
   * Get its attributes in "*attr".
   */
      static int
  fillchar_vsep(int *attr)
  {
      *attr = HL_ATTR(HLF_C);
      if (*attr == 0 && fill_vert == ' ')
  	return '|';
      else
  	return fill_vert;
  }
  
  /*
   * Return TRUE if redrawing should currently be done.
   */
      int
  redrawing(void)
  {
  #ifdef FEAT_EVAL
      if (disable_redraw_for_testing)
  	return 0;
      else
  #endif
  	return (!RedrawingDisabled
  		       && !(p_lz && char_avail() && !KeyTyped && !do_redraw));
  }
  
  /*
   * Return TRUE if printing messages should currently be done.
   */
      int
  messaging(void)
  {
      return (!(p_lz && char_avail() && !KeyTyped));
  }
  
  #ifdef FEAT_MENU
  /*
   * Draw the window toolbar.
   */
      static void
  redraw_win_toolbar(win_T *wp)
  {
      vimmenu_T	*menu;
      int		item_idx = 0;
      int		item_count = 0;
      int		col = 0;
      int		next_col;
      int		off = (int)(current_ScreenLine - ScreenLines);
      int		fill_attr = syn_name2attr((char_u *)"ToolbarLine");
      int		button_attr = syn_name2attr((char_u *)"ToolbarButton");
  
      vim_free(wp->w_winbar_items);
      for (menu = wp->w_winbar->children; menu != NULL; menu = menu->next)
  	++item_count;
      wp->w_winbar_items = (winbar_item_T *)alloc_clear(
  			   (unsigned)sizeof(winbar_item_T) * (item_count + 1));
  
      /* TODO: use fewer spaces if there is not enough room */
      for (menu = wp->w_winbar->children;
  			  menu != NULL && col < wp->w_width; menu = menu->next)
      {
  	space_to_screenline(off + col, fill_attr);
  	if (++col >= wp->w_width)
  	    break;
  	if (col > 1)
  	{
  	    space_to_screenline(off + col, fill_attr);
  	    if (++col >= wp->w_width)
  		break;
  	}
  
  	wp->w_winbar_items[item_idx].wb_startcol = col;
  	space_to_screenline(off + col, button_attr);
  	if (++col >= wp->w_width)
  	    break;
  
  	next_col = text_to_screenline(wp, menu->name, col);
  	while (col < next_col)
  	{
  	    ScreenAttrs[off + col] = button_attr;
  	    ++col;
  	}
  	wp->w_winbar_items[item_idx].wb_endcol = col;
  	wp->w_winbar_items[item_idx].wb_menu = menu;
  	++item_idx;
  
  	if (col >= wp->w_width)
  	    break;
  	space_to_screenline(off + col, button_attr);
  	++col;
      }
      while (col < wp->w_width)
      {
  	space_to_screenline(off + col, fill_attr);
  	++col;
      }
      wp->w_winbar_items[item_idx].wb_menu = NULL; /* end marker */
  
      screen_line(wp->w_winrow, wp->w_wincol, (int)wp->w_width,
  						     (int)wp->w_width, FALSE);
  }
  #endif
  /*
   * Show current status info in ruler and various other places
   * If always is FALSE, only show ruler if position has changed.
   */
      void
  showruler(int always)
  {
      if (!always && !redrawing())
  	return;
  #ifdef FEAT_INS_EXPAND
      if (pum_visible())
      {
  	/* Don't redraw right now, do it later. */
  	curwin->w_redr_status = TRUE;
  	return;
      }
  #endif
  #if defined(FEAT_STL_OPT)
      if ((*p_stl != NUL || *curwin->w_p_stl != NUL) && curwin->w_status_height)
      {
  	redraw_custom_statusline(curwin);
      }
      else
  #endif
  #ifdef FEAT_CMDL_INFO
  	win_redr_ruler(curwin, always);
  #endif
  
  #ifdef FEAT_TITLE
      if (need_maketitle
  # ifdef FEAT_STL_OPT
  	    || (p_icon && (stl_syntax & STL_IN_ICON))
  	    || (p_title && (stl_syntax & STL_IN_TITLE))
  # endif
         )
  	maketitle();
  #endif
      /* Redraw the tab pages line if needed. */
      if (redraw_tabline)
  	draw_tabline();
  }
  
  #ifdef FEAT_CMDL_INFO
      static void
  win_redr_ruler(win_T *wp, int always)
  {
  #define RULER_BUF_LEN 70
      char_u	buffer[RULER_BUF_LEN];
      int		row;
      int		fillchar;
      int		attr;
      int		empty_line = FALSE;
      colnr_T	virtcol;
      int		i;
      size_t	len;
      int		o;
      int		this_ru_col;
      int		off = 0;
      int		width = Columns;
  
      /* If 'ruler' off or redrawing disabled, don't do anything */
      if (!p_ru)
  	return;
  
      /*
       * Check if cursor.lnum is valid, since win_redr_ruler() may be called
       * after deleting lines, before cursor.lnum is corrected.
       */
      if (wp->w_cursor.lnum > wp->w_buffer->b_ml.ml_line_count)
  	return;
  
  #ifdef FEAT_INS_EXPAND
      /* Don't draw the ruler while doing insert-completion, it might overwrite
       * the (long) mode message. */
      if (wp == lastwin && lastwin->w_status_height == 0)
  	if (edit_submode != NULL)
  	    return;
      /* Don't draw the ruler when the popup menu is visible, it may overlap. */
      if (pum_visible())
  	return;
  #endif
  
  #ifdef FEAT_STL_OPT
      if (*p_ruf)
      {
  	int	save_called_emsg = called_emsg;
  
  	called_emsg = FALSE;
  	win_redr_custom(wp, TRUE);
  	if (called_emsg)
  	    set_string_option_direct((char_u *)"rulerformat", -1,
  					   (char_u *)"", OPT_FREE, SID_ERROR);
  	called_emsg |= save_called_emsg;
  	return;
      }
  #endif
  
      /*
       * Check if not in Insert mode and the line is empty (will show "0-1").
       */
      if (!(State & INSERT)
  		&& *ml_get_buf(wp->w_buffer, wp->w_cursor.lnum, FALSE) == NUL)
  	empty_line = TRUE;
  
      /*
       * Only draw the ruler when something changed.
       */
      validate_virtcol_win(wp);
      if (       redraw_cmdline
  	    || always
  	    || wp->w_cursor.lnum != wp->w_ru_cursor.lnum
  	    || wp->w_cursor.col != wp->w_ru_cursor.col
  	    || wp->w_virtcol != wp->w_ru_virtcol
  #ifdef FEAT_VIRTUALEDIT
  	    || wp->w_cursor.coladd != wp->w_ru_cursor.coladd
  #endif
  	    || wp->w_topline != wp->w_ru_topline
  	    || wp->w_buffer->b_ml.ml_line_count != wp->w_ru_line_count
  #ifdef FEAT_DIFF
  	    || wp->w_topfill != wp->w_ru_topfill
  #endif
  	    || empty_line != wp->w_ru_empty)
      {
  	cursor_off();
  	if (wp->w_status_height)
  	{
  	    row = W_WINROW(wp) + wp->w_height;
  	    fillchar = fillchar_status(&attr, wp);
  	    off = wp->w_wincol;
  	    width = wp->w_width;
  	}
  	else
  	{
  	    row = Rows - 1;
  	    fillchar = ' ';
  	    attr = 0;
  	    width = Columns;
  	    off = 0;
  	}
  
  	/* In list mode virtcol needs to be recomputed */
  	virtcol = wp->w_virtcol;
  	if (wp->w_p_list && lcs_tab1 == NUL)
  	{
  	    wp->w_p_list = FALSE;
  	    getvvcol(wp, &wp->w_cursor, NULL, &virtcol, NULL);
  	    wp->w_p_list = TRUE;
  	}
  
  	/*
  	 * Some sprintfs return the length, some return a pointer.
  	 * To avoid portability problems we use strlen() here.
  	 */
  	vim_snprintf((char *)buffer, RULER_BUF_LEN, "%ld,",
  		(wp->w_buffer->b_ml.ml_flags & ML_EMPTY)
  		    ? 0L
  		    : (long)(wp->w_cursor.lnum));
  	len = STRLEN(buffer);
  	col_print(buffer + len, RULER_BUF_LEN - len,
  			empty_line ? 0 : (int)wp->w_cursor.col + 1,
  			(int)virtcol + 1);
  
  	/*
  	 * Add a "50%" if there is room for it.
  	 * On the last line, don't print in the last column (scrolls the
  	 * screen up on some terminals).
  	 */
  	i = (int)STRLEN(buffer);
  	get_rel_pos(wp, buffer + i + 1, RULER_BUF_LEN - i - 1);
  	o = i + vim_strsize(buffer + i + 1);
  	if (wp->w_status_height == 0)	/* can't use last char of screen */
  	    ++o;
  	this_ru_col = ru_col - (Columns - width);
  	if (this_ru_col < 0)
  	    this_ru_col = 0;
  	/* Never use more than half the window/screen width, leave the other
  	 * half for the filename. */
  	if (this_ru_col < (width + 1) / 2)
  	    this_ru_col = (width + 1) / 2;
  	if (this_ru_col + o < width)
  	{
  	    /* need at least 3 chars left for get_rel_pos() + NUL */
  	    while (this_ru_col + o < width && RULER_BUF_LEN > i + 4)
  	    {
  #ifdef FEAT_MBYTE
  		if (has_mbyte)
  		    i += (*mb_char2bytes)(fillchar, buffer + i);
  		else
  #endif
  		    buffer[i++] = fillchar;
  		++o;
  	    }
  	    get_rel_pos(wp, buffer + i, RULER_BUF_LEN - i);
  	}
  	/* Truncate at window boundary. */
  #ifdef FEAT_MBYTE
  	if (has_mbyte)
  	{
  	    o = 0;
  	    for (i = 0; buffer[i] != NUL; i += (*mb_ptr2len)(buffer + i))
  	    {
  		o += (*mb_ptr2cells)(buffer + i);
  		if (this_ru_col + o > width)
  		{
  		    buffer[i] = NUL;
  		    break;
  		}
  	    }
  	}
  	else
  #endif
  	if (this_ru_col + (int)STRLEN(buffer) > width)
  	    buffer[width - this_ru_col] = NUL;
  
  	screen_puts(buffer, row, this_ru_col + off, attr);
  	i = redraw_cmdline;
  	screen_fill(row, row + 1,
  		this_ru_col + off + (int)STRLEN(buffer),
  		(int)(off + width),
  		fillchar, fillchar, attr);
  	/* don't redraw the cmdline because of showing the ruler */
  	redraw_cmdline = i;
  	wp->w_ru_cursor = wp->w_cursor;
  	wp->w_ru_virtcol = wp->w_virtcol;
  	wp->w_ru_empty = empty_line;
  	wp->w_ru_topline = wp->w_topline;
  	wp->w_ru_line_count = wp->w_buffer->b_ml.ml_line_count;
  #ifdef FEAT_DIFF
  	wp->w_ru_topfill = wp->w_topfill;
  #endif
      }
  }
  #endif
  
  #if defined(FEAT_LINEBREAK) || defined(PROTO)
  /*
   * Return the width of the 'number' and 'relativenumber' column.
   * Caller may need to check if 'number' or 'relativenumber' is set.
   * Otherwise it depends on 'numberwidth' and the line count.
   */
      int
  number_width(win_T *wp)
  {
      int		n;
      linenr_T	lnum;
  
      if (wp->w_p_rnu && !wp->w_p_nu)
  	/* cursor line shows "0" */
  	lnum = wp->w_height;
      else
  	/* cursor line shows absolute line number */
  	lnum = wp->w_buffer->b_ml.ml_line_count;
  
      if (lnum == wp->w_nrwidth_line_count && wp->w_nuw_cached == wp->w_p_nuw)
  	return wp->w_nrwidth_width;
      wp->w_nrwidth_line_count = lnum;
  
      n = 0;
      do
      {
  	lnum /= 10;
  	++n;
      } while (lnum > 0);
  
      /* 'numberwidth' gives the minimal width plus one */
      if (n < wp->w_p_nuw - 1)
  	n = wp->w_p_nuw - 1;
  
      wp->w_nrwidth_width = n;
      wp->w_nuw_cached = wp->w_p_nuw;
      return n;
  }
  #endif
  
  /*
   * Return the current cursor column. This is the actual position on the
   * screen. First column is 0.
   */
      int
  screen_screencol(void)
  {
      return screen_cur_col;
  }
  
  /*
   * Return the current cursor row. This is the actual position on the screen.
   * First row is 0.
   */
      int
  screen_screenrow(void)
  {
      return screen_cur_row;
  }
  