/* display.c -- readline redisplay facility. */
-/* Copyright (C) 1987-2013 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2009 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
#include <stdio.h>
#ifdef __MSDOS__
+# include <pc.h>
#endif
/* System-specific feature definitions and include files. */
static void space_to_eol PARAMS((int));
static void delete_chars PARAMS((int));
static void insert_some_chars PARAMS((char *, int, int));
-static void open_some_spaces PARAMS((int));
static void cr PARAMS((void));
-static void redraw_prompt PARAMS((char *));
-
-/* Values for FLAGS */
-#define PMT_MULTILINE 0x01
-
-static char *expand_prompt PARAMS((char *, int, int *, int *, int *, int *));
/* State of visible and invisible lines. */
struct line_state
This is usually pointing to rl_prompt. */
char *rl_display_prompt = (char *)NULL;
-/* Variables used to include the editing mode in the prompt. */
-char *_rl_emacs_mode_str;
-int _rl_emacs_modestr_len;
-
-char *_rl_vi_ins_mode_str;
-int _rl_vi_ins_modestr_len;
-
-char *_rl_vi_cmd_mode_str;
-int _rl_vi_cmd_modestr_len;
-
/* Pseudo-global variables declared here. */
/* The visible cursor position. If you print some text, adjust this. */
static int cpos_adjusted;
static int cpos_buffer_position;
-static int displaying_prompt_first_line;
static int prompt_multibyte_chars;
/* Number of lines currently on screen minus 1. */
static int last_lmargin;
/* A buffer for `modeline' messages. */
-static char *msg_buf = 0;
-static int msg_bufsiz = 0;
+static char msg_buf[128];
/* Non-zero forces the redisplay even if we thought it was unnecessary. */
static int forced_display;
static int saved_invis_chars_first_line;
static int saved_physical_chars;
-/* Return a string indicating the editing mode, for use in the prompt. */
-
-static char *
-prompt_modestr (lenp)
- int *lenp;
-{
- if (rl_editing_mode == emacs_mode)
- {
- if (lenp)
- *lenp = _rl_emacs_mode_str ? _rl_emacs_modestr_len : RL_EMACS_MODESTR_DEFLEN;
- return _rl_emacs_mode_str ? _rl_emacs_mode_str : RL_EMACS_MODESTR_DEFAULT;
- }
- else if (_rl_keymap == vi_insertion_keymap)
- {
- if (lenp)
- *lenp = _rl_vi_ins_mode_str ? _rl_vi_ins_modestr_len : RL_VI_INS_MODESTR_DEFLEN;
- return _rl_vi_ins_mode_str ? _rl_vi_ins_mode_str : RL_VI_INS_MODESTR_DEFAULT; /* vi insert mode */
- }
- else
- {
- if (lenp)
- *lenp = _rl_vi_cmd_mode_str ? _rl_vi_cmd_modestr_len : RL_VI_CMD_MODESTR_DEFLEN;
- return _rl_vi_cmd_mode_str ? _rl_vi_cmd_mode_str : RL_VI_CMD_MODESTR_DEFAULT; /* vi command mode */
- }
-}
-
/* Expand the prompt string S and return the number of visible
characters in *LP, if LP is not null. This is currently more-or-less
a placeholder for expansion. LIP, if non-null is a place to store the
the returned string; all characters except those between \001 and
\002 are assumed to be `visible'. */
-/* Possible values for FLAGS:
- PMT_MULTILINE caller indicates that this is part of a multiline prompt
-*/
-
static char *
-expand_prompt (pmt, flags, lp, lip, niflp, vlp)
+expand_prompt (pmt, lp, lip, niflp, vlp)
char *pmt;
- int flags;
int *lp, *lip, *niflp, *vlp;
{
- char *r, *ret, *p, *igstart, *nprompt, *ms;
+ char *r, *ret, *p, *igstart;
int l, rl, last, ignoring, ninvis, invfl, invflset, ind, pind, physchars;
- int mlen;
-
- /* We only expand the mode string for the last line of a multiline prompt
- (a prompt with embedded newlines). */
- ms = (((pmt == rl_prompt) ^ (flags & PMT_MULTILINE)) && _rl_show_mode_in_prompt) ? prompt_modestr (&mlen) : 0;
- if (ms)
- {
- l = strlen (pmt);
- nprompt = (char *)xmalloc (l + mlen + 1);
- memcpy (nprompt, ms, mlen);
- strcpy (nprompt + mlen, pmt);
- }
- else
- nprompt = pmt;
/* Short-circuit if we can. */
- if ((MB_CUR_MAX <= 1 || rl_byte_oriented) && strchr (nprompt, RL_PROMPT_START_IGNORE) == 0)
+ if ((MB_CUR_MAX <= 1 || rl_byte_oriented) && strchr (pmt, RL_PROMPT_START_IGNORE) == 0)
{
- r = (nprompt == pmt) ? savestring (pmt) : nprompt;
-
+ r = savestring (pmt);
if (lp)
*lp = strlen (r);
if (lip)
return r;
}
- l = strlen (nprompt); /* XXX */
+ l = strlen (pmt);
r = ret = (char *)xmalloc (l + 1);
- rl = physchars = 0; /* mode string now part of nprompt */
invfl = 0; /* invisible chars in first line of prompt */
invflset = 0; /* we only want to set invfl once */
- igstart = 0;
- for (ignoring = last = ninvis = 0, p = nprompt; p && *p; p++)
+ igstart = 0;
+ for (rl = ignoring = last = ninvis = physchars = 0, p = pmt; p && *p; p++)
{
/* This code strips the invisible character string markers
RL_PROMPT_START_IGNORE and RL_PROMPT_END_IGNORE */
#if defined (HANDLE_MULTIBYTE)
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
{
- pind = p - nprompt;
- ind = _rl_find_next_mbchar (nprompt, pind, 1, MB_FIND_NONZERO);
+ pind = p - pmt;
+ ind = _rl_find_next_mbchar (pmt, pind, 1, MB_FIND_NONZERO);
l = ind - pind;
while (l--)
*r++ = *p++;
not be the same as the number of physical characters
on the screen in the presence of multibyte characters */
rl += ind - pind;
- physchars += _rl_col_width (nprompt, pind, ind, 0);
+ physchars += _rl_col_width (pmt, pind, ind, 0);
}
else
ninvis += ind - pind;
*niflp = invfl;
if (vlp)
*vlp = physchars;
-
- if (nprompt != pmt)
- free (nprompt);
-
return ret;
}
{
char *ret;
- ret = expand_prompt (pmt, 0, (int *)NULL, (int *)NULL, (int *)NULL, (int *)NULL);
+ ret = expand_prompt (pmt, (int *)NULL, (int *)NULL, (int *)NULL, (int *)NULL);
return ret;
}
-void
-_rl_reset_prompt ()
-{
- rl_visible_prompt_length = rl_expand_prompt (rl_prompt);
-}
-
/*
* Expand the prompt string into the various display components, if
* necessary.
return (0);
p = strrchr (prompt, '\n');
- if (p == 0)
+ if (!p)
{
/* The prompt is only one logical line, though it might wrap. */
- local_prompt = expand_prompt (prompt, 0, &prompt_visible_length,
- &prompt_last_invisible,
- &prompt_invis_chars_first_line,
- &prompt_physical_chars);
+ local_prompt = expand_prompt (prompt, &prompt_visible_length,
+ &prompt_last_invisible,
+ &prompt_invis_chars_first_line,
+ &prompt_physical_chars);
local_prompt_prefix = (char *)0;
local_prompt_len = local_prompt ? strlen (local_prompt) : 0;
return (prompt_visible_length);
{
/* The prompt spans multiple lines. */
t = ++p;
- local_prompt = expand_prompt (p, PMT_MULTILINE,
- &prompt_visible_length,
+ local_prompt = expand_prompt (p, &prompt_visible_length,
&prompt_last_invisible,
&prompt_invis_chars_first_line,
&prompt_physical_chars);
c = *t; *t = '\0';
/* The portion of the prompt string up to and including the
final newline is now null-terminated. */
- local_prompt_prefix = expand_prompt (prompt, PMT_MULTILINE,
- &prompt_prefix_length,
+ local_prompt_prefix = expand_prompt (prompt, &prompt_prefix_length,
(int *)NULL,
(int *)NULL,
(int *)NULL);
{
register int n;
+ if (minsize <= _rl_screenwidth) /* XXX - for gdb */
+ minsize = _rl_screenwidth + 1;
+
if (invisible_line == 0) /* initialize it */
{
if (line_size < minsize)
int wc_width;
mbstate_t ps;
int _rl_wrapped_multicolumn = 0;
- int mb_cur_max = MB_CUR_MAX;
#endif
if (_rl_echoing_p == 0)
init_line_structures (0);
rl_on_new_line ();
}
+ else if (line_size <= _rl_screenwidth)
+ init_line_structures (_rl_screenwidth + 1);
/* Draw the line into the buffer. */
cpos_buffer_position = -1;
contents of the command line? */
while (lpos >= _rl_screenwidth)
{
- int z, p;
+ int z;
/* fix from Darin Johnson <darin@acuson.com> for prompt string with
invisible characters that is longer than the screen width. The
prompt_invis_chars_first_line variable could be made into an array
prompts that exceed two physical lines?
Additional logic fix from Edward Catmur <ed@catmur.co.uk> */
#if defined (HANDLE_MULTIBYTE)
- if (mb_cur_max > 1 && rl_byte_oriented == 0 && prompt_multibyte_chars > 0)
+ if (MB_CUR_MAX > 1 && rl_byte_oriented == 0 && prompt_multibyte_chars > 0)
{
n0 = num;
temp = local_prompt_len;
break;
}
else if (z == _rl_screenwidth)
- {
- /* If we are in the middle or at the end of a multibyte
- character, we want to move to the start, then find out
- where it ends so we know where to insert the newline.
- If this isn't a multibyte character, its the same as num++ */
- p = _rl_find_prev_mbchar (local_prompt, num, MB_FIND_ANY);
- num = _rl_find_next_mbchar (local_prompt, p, 1, MB_FIND_ANY);
- break;
- }
+ break;
num++;
}
temp = num;
/* Now account for invisible characters in the current line. */
/* XXX - this assumes that the invisible characters may be split, but only
between the first and the last lines. */
- temp += (newlines == 0) ? prompt_invis_chars_first_line
- : ((newlines == prompt_lines_estimate) ? wrap_offset : prompt_invis_chars_first_line);
-
+ temp += ((local_prompt_prefix == 0) ? ((newlines == 0) ? prompt_invis_chars_first_line
+ : ((newlines == prompt_lines_estimate) ? wrap_offset : prompt_invis_chars_first_line))
+ : ((newlines == 0) ? wrap_offset : 0));
+
inv_lbreaks[++newlines] = temp;
#if defined (HANDLE_MULTIBYTE)
- if (mb_cur_max > 1 && rl_byte_oriented == 0 && prompt_multibyte_chars > 0)
+ if (MB_CUR_MAX > 1 && rl_byte_oriented == 0 && prompt_multibyte_chars > 0)
lpos -= _rl_col_width (local_prompt, n0, num, 1);
else
#endif
lb_linenum = 0;
#if defined (HANDLE_MULTIBYTE)
in = 0;
- if (mb_cur_max > 1 && rl_byte_oriented == 0)
+ if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
{
memset (&ps, 0, sizeof (mbstate_t));
/* XXX - what if wc_bytes ends up <= 0? check for MB_INVALIDCH */
c = (unsigned char)rl_line_buffer[in];
#if defined (HANDLE_MULTIBYTE)
- if (mb_cur_max > 1 && rl_byte_oriented == 0)
+ if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
{
if (MB_INVALIDCH (wc_bytes))
{
break; /* Found '\0' */
else
{
- temp = WCWIDTH (wc);
+ temp = wcwidth (wc);
wc_width = (temp >= 0) ? temp : 1;
}
}
else
{
#if defined (HANDLE_MULTIBYTE)
- if (mb_cur_max > 1 && rl_byte_oriented == 0)
+ if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
{
register int i;
}
#if defined (HANDLE_MULTIBYTE)
- if (mb_cur_max > 1 && rl_byte_oriented == 0)
+ if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
{
in += wc_bytes;
/* XXX - what if wc_bytes ends up <= 0? check for MB_INVALIDCH */
/* If we can move the cursor up and down, then use multiple lines,
otherwise, let long lines display in a single terminal line, and
horizontally scroll it. */
- displaying_prompt_first_line = 1;
+
if (_rl_horizontal_scroll_mode == 0 && _rl_term_up && *_rl_term_up)
{
int nleft, pos, changed_screen_line, tx;
not the first. */
if (out >= _rl_screenchars)
{
- if (mb_cur_max > 1 && rl_byte_oriented == 0)
+ if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
out = _rl_find_prev_mbchar (line, _rl_screenchars, MB_FIND_ANY);
else
out = _rl_screenchars - 1;
time update_line is called, then we can assume in our
calculations that o_cpos does not need to be adjusted by
wrap_offset. */
- if (linenum == 0 && (mb_cur_max > 1 && rl_byte_oriented == 0) && OLD_CPOS_IN_PROMPT())
+ if (linenum == 0 && (MB_CUR_MAX > 1 && rl_byte_oriented == 0) && OLD_CPOS_IN_PROMPT())
_rl_last_c_pos -= prompt_invis_chars_first_line; /* XXX - was wrap_offset */
else if (linenum == prompt_last_screen_line && prompt_physical_chars > _rl_screenwidth &&
- (mb_cur_max > 1 && rl_byte_oriented == 0) &&
+ (MB_CUR_MAX > 1 && rl_byte_oriented == 0) &&
cpos_adjusted == 0 &&
_rl_last_c_pos != o_cpos &&
_rl_last_c_pos > (prompt_last_invisible - _rl_screenwidth - prompt_invis_chars_first_line))
_rl_last_c_pos -= (wrap_offset-prompt_invis_chars_first_line);
-
+
/* If this is the line with the prompt, we might need to
compensate for invisible characters in the new line. Do
this only if there is not more than one new line (which
(wrap_offset > visible_wrap_offset) &&
(_rl_last_c_pos < visible_first_line_len))
{
- if (mb_cur_max > 1 && rl_byte_oriented == 0)
+ if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
nleft = _rl_screenwidth - _rl_last_c_pos;
else
nleft = _rl_screenwidth + wrap_offset - _rl_last_c_pos;
the physical cursor position on the screen stays the same,
but the buffer position needs to be adjusted to account
for invisible characters. */
- if ((mb_cur_max == 1 || rl_byte_oriented) && cursor_linenum == 0 && wrap_offset)
+ if ((MB_CUR_MAX == 1 || rl_byte_oriented) && cursor_linenum == 0 && wrap_offset)
_rl_last_c_pos += wrap_offset;
}
_rl_output_some_chars ("*", 1);
_rl_output_some_chars (local_prompt, nleft);
- if (mb_cur_max > 1 && rl_byte_oriented == 0)
+ if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
_rl_last_c_pos = _rl_col_width (local_prompt, 0, nleft, 1) - wrap_offset + modmark;
else
_rl_last_c_pos = nleft + modmark;
if (wrap_offset && cursor_linenum == 0 && nleft < _rl_last_c_pos)
{
/* TX == new physical cursor position in multibyte locale. */
- if (mb_cur_max > 1 && rl_byte_oriented == 0)
+ if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
tx = _rl_col_width (&visible_line[pos], 0, nleft, 1) - visible_wrap_offset;
else
tx = nleft;
_rl_last_c_pos as an absolute cursor position, but moving to a
point specified by a buffer position (NLEFT) that doesn't take
invisible characters into account. */
- if (mb_cur_max > 1 && rl_byte_oriented == 0)
+ if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
_rl_move_cursor_relative (nleft, &invisible_line[pos]);
else if (nleft != _rl_last_c_pos)
_rl_move_cursor_relative (nleft, &invisible_line[pos]);
else
lmargin = last_lmargin;
- displaying_prompt_first_line = lmargin < nleft;
-
/* If the first character on the screen isn't the first character
in the display line, indicate this with a special character. */
if (lmargin > 0)
_rl_screenwidth + (lmargin ? 0 : wrap_offset),
0);
- if ((mb_cur_max > 1 && rl_byte_oriented == 0) &&
- displaying_prompt_first_line && OLD_CPOS_IN_PROMPT())
+ if ((MB_CUR_MAX > 1 && rl_byte_oriented == 0) && OLD_CPOS_IN_PROMPT())
_rl_last_c_pos -= prompt_invis_chars_first_line; /* XXX - was wrap_offset */
/* If the visible new line is shorter than the old, but the number
the new line, we need to clear to eol. */
t = _rl_last_c_pos - M_OFFSET (lmargin, wrap_offset);
if ((M_OFFSET (lmargin, wrap_offset) > visible_wrap_offset) &&
- (_rl_last_c_pos == out) && displaying_prompt_first_line &&
+ (_rl_last_c_pos == out) &&
t < visible_first_line_len)
{
nleft = _rl_screenwidth - t;
int temp, lendiff, wsatend, od, nd, twidth, o_cpos;
int current_invis_chars;
int col_lendiff, col_temp;
- int bytes_to_insert;
#if defined (HANDLE_MULTIBYTE)
mbstate_t ps_new, ps_old;
int new_offset, old_offset;
size_t ret;
/* This fixes only double-column characters, but if the wrapped
- character consumes more than three columns, spaces will be
+ character comsumes more than three columns, spaces will be
inserted in the string buffer. */
if (current_line < line_state_visible->wbsize && line_state_visible->wrapped_line[current_line] > 0)
_rl_clear_to_eol (line_state_visible->wrapped_line[current_line]);
else if (MB_NULLWCH (ret))
tempwidth = 0;
else
- tempwidth = WCWIDTH (wc);
+ tempwidth = wcwidth (wc);
if (tempwidth > 0)
{
memcpy (old, new, bytes);
/* Fix up indices if we copy data from one line to another */
omax += bytes - ret;
- for (i = current_line+1; i <= inv_botlin+1; i++)
+ for (i = current_line+1; i < inv_botlin+1; i++)
vis_lbreaks[i] += bytes - ret;
}
}
temp = (omax < nmax) ? omax : nmax;
if (memcmp (old, new, temp) == 0) /* adding at the end */
{
- new_offset = old_offset = temp;
ofd = old + temp;
nfd = new + temp;
}
if (omax == nmax && STREQN (new, old, omax))
{
- old_offset = omax;
- new_offset = nmax;
ofd = old + omax;
nfd = new + nmax;
}
{
old_offset = _rl_find_next_mbchar (old, old_offset, 1, MB_FIND_ANY);
new_offset = _rl_find_next_mbchar (new, new_offset, 1, MB_FIND_ANY);
-
ofd = old + old_offset;
nfd = new + new_offset;
}
if (ofd == oe && nfd == ne)
return;
-#if defined (HANDLE_MULTIBYTE)
- if (MB_CUR_MAX > 1 && rl_byte_oriented == 0 && _rl_utf8locale)
- {
- wchar_t wc;
- mbstate_t ps = { 0 };
- int t;
-
- /* If the first character in the difference is a zero-width character,
- assume it's a combining character and back one up so the two base
- characters no longer compare equivalently. */
- t = mbrtowc (&wc, ofd, MB_CUR_MAX, &ps);
- if (t > 0 && UNICODE_COMBINING_CHAR (wc) && WCWIDTH (wc) == 0)
- {
- old_offset = _rl_find_prev_mbchar (old, ofd - old, MB_FIND_ANY);
- new_offset = _rl_find_prev_mbchar (new, nfd - new, MB_FIND_ANY);
- ofd = old + old_offset; /* equal by definition */
- nfd = new + new_offset;
- }
- }
-#endif
-
wsatend = 1; /* flag for trailing whitespace */
#if defined (HANDLE_MULTIBYTE)
{
ols = old + _rl_find_prev_mbchar (old, oe - old, MB_FIND_ANY);
nls = new + _rl_find_prev_mbchar (new, ne - new, MB_FIND_ANY);
-
while ((ols > ofd) && (nls > nfd))
{
memset (&ps_old, 0, sizeof (mbstate_t));
o_cpos = _rl_last_c_pos;
/* When this function returns, _rl_last_c_pos is correct, and an absolute
- cursor position in multibyte mode, but a buffer index when not in a
+ cursor postion in multibyte mode, but a buffer index when not in a
multibyte locale. */
_rl_move_cursor_relative (od, old);
-
+#if 1
#if defined (HANDLE_MULTIBYTE)
/* We need to indicate that the cursor position is correct in the presence of
invisible characters in the prompt string. Let's see if setting this when
(_rl_last_c_pos > 0 || o_cpos > 0) &&
_rl_last_c_pos == prompt_physical_chars)
cpos_adjusted = 1;
+#endif
#endif
/* if (len (new) > len (old))
- lendiff == difference in buffer (bytes)
- col_lendiff == difference on screen (columns)
+ lendiff == difference in buffer
+ col_lendiff == difference on screen
When not using multibyte characters, these are equal */
lendiff = (nls - nfd) - (ols - ofd);
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
/* If we are changing the number of invisible characters in a line, and
the spot of first difference is before the end of the invisible chars,
lendiff needs to be adjusted. */
- if (current_line == 0 && /* !_rl_horizontal_scroll_mode && */
+ if (current_line == 0 && !_rl_horizontal_scroll_mode &&
current_invis_chars != visible_wrap_offset)
{
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
}
}
- /* We use temp as a count of the number of bytes from the first difference
- to the end of the new line. col_temp is the corresponding number of
- screen columns. A `dumb' update moves to the spot of first difference
- and writes TEMP bytes. */
/* Insert (diff (len (old), len (new)) ch. */
temp = ne - nfd;
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
else
col_temp = temp;
- /* how many bytes from the new line buffer to write to the display */
- bytes_to_insert = nls - nfd;
-
- /* col_lendiff > 0 if we are adding characters to the line */
if (col_lendiff > 0) /* XXX - was lendiff */
{
/* Non-zero if we're increasing the number of lines. */
if (lendiff < 0)
{
_rl_output_some_chars (nfd, temp);
- _rl_last_c_pos += col_temp; /* XXX - was _rl_col_width (nfd, 0, temp, 1); */
+ _rl_last_c_pos += _rl_col_width (nfd, 0, temp, 1);
/* If nfd begins before any invisible characters in the prompt,
adjust _rl_last_c_pos to account for wrap_offset and set
cpos_adjusted to let the caller know. */
- if (current_line == 0 && displaying_prompt_first_line && wrap_offset && ((nfd - new) <= prompt_last_invisible))
+ if (current_line == 0 && wrap_offset && ((nfd - new) <= prompt_last_invisible))
{
_rl_last_c_pos -= wrap_offset;
cpos_adjusted = 1;
(col_lendiff < prompt_visible_length)) == 0) &&
(visible_wrap_offset >= current_invis_chars))
{
- open_some_spaces (col_lendiff);
- _rl_output_some_chars (nfd, bytes_to_insert);
- if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
- _rl_last_c_pos += _rl_col_width (nfd, 0, bytes_to_insert, 1);
- else
- _rl_last_c_pos += bytes_to_insert;
+ insert_some_chars (nfd, lendiff, col_lendiff);
+ _rl_last_c_pos += col_lendiff;
}
+#if 0 /* XXX - for now */
+ else if ((MB_CUR_MAX > 1 && rl_byte_oriented == 0) && _rl_last_c_pos == 0 && wrap_offset && (nfd-new) <= prompt_last_invisible && col_lendiff < prompt_visible_length && visible_wrap_offset >= current_invis_chars)
+ {
+ _rl_output_some_chars (nfd, lendiff);
+ _rl_last_c_pos += col_lendiff;
+ }
+#endif
else if ((MB_CUR_MAX == 1 || rl_byte_oriented != 0) && *ols == 0 && lendiff > 0)
{
/* At the end of a line the characters do not have to
be "inserted". They can just be placed on the screen. */
- _rl_output_some_chars (nfd, temp);
- _rl_last_c_pos += col_temp;
- return;
+ /* However, this screws up the rest of this block, which
+ assumes you've done the insert because you can. */
+ _rl_output_some_chars (nfd, lendiff);
+ _rl_last_c_pos += col_lendiff;
}
- else /* just write from first difference to end of new line */
+ else
{
_rl_output_some_chars (nfd, temp);
_rl_last_c_pos += col_temp;
/* If nfd begins before the last invisible character in the
prompt, adjust _rl_last_c_pos to account for wrap_offset
and set cpos_adjusted to let the caller know. */
- if ((MB_CUR_MAX > 1 && rl_byte_oriented == 0) && current_line == 0 && displaying_prompt_first_line && wrap_offset && ((nfd - new) <= prompt_last_invisible))
+ if ((MB_CUR_MAX > 1 && rl_byte_oriented == 0) && current_line == 0 && wrap_offset && ((nfd - new) <= prompt_last_invisible))
{
_rl_last_c_pos -= wrap_offset;
cpos_adjusted = 1;
}
return;
}
-
- if (bytes_to_insert > lendiff)
+ /* Copy (new) chars to screen from first diff to last match. */
+ temp = nls - nfd;
+ if ((temp - lendiff) > 0)
{
+ _rl_output_some_chars (nfd + lendiff, temp - lendiff);
+ /* XXX -- this bears closer inspection. Fixes a redisplay bug
+ reported against bash-3.0-alpha by Andreas Schwab involving
+ multibyte characters and prompt strings with invisible
+ characters, but was previously disabled. */
+ if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
+ twidth = _rl_col_width (nfd+lendiff, 0, temp-col_lendiff, 1);
+ else
+ twidth = temp - lendiff;
+ _rl_last_c_pos += twidth;
/* If nfd begins before the last invisible character in the
prompt, adjust _rl_last_c_pos to account for wrap_offset
and set cpos_adjusted to let the caller know. */
- if ((MB_CUR_MAX > 1 && rl_byte_oriented == 0) && current_line == 0 && displaying_prompt_first_line && wrap_offset && ((nfd - new) <= prompt_last_invisible))
+ if ((MB_CUR_MAX > 1 && rl_byte_oriented == 0) && current_line == 0 && wrap_offset && ((nfd - new) <= prompt_last_invisible))
{
_rl_last_c_pos -= wrap_offset;
cpos_adjusted = 1;
a physical character position. */
if ((MB_CUR_MAX > 1 && rl_byte_oriented == 0) &&
current_line == prompt_last_screen_line && wrap_offset &&
- displaying_prompt_first_line &&
wrap_offset != prompt_invis_chars_first_line &&
((nfd-new) < (prompt_last_invisible-(current_line*_rl_screenwidth))))
{
prompt string, don't bother. It screws up the assumptions
about what's on the screen. */
if (_rl_horizontal_scroll_mode && _rl_last_c_pos == 0 &&
- displaying_prompt_first_line &&
-lendiff == visible_wrap_offset)
col_lendiff = 0;
- /* If we have moved lmargin and we're shrinking the line, we've
- already moved the cursor to the first character of the new line,
- so deleting -col_lendiff characters will mess up the cursor
- position calculation */
- if (_rl_horizontal_scroll_mode && displaying_prompt_first_line == 0 &&
- col_lendiff && _rl_last_c_pos < -col_lendiff)
- col_lendiff = 0;
-
if (col_lendiff)
delete_chars (-col_lendiff); /* delete (diff) characters */
- /* Copy (new) chars to screen from first diff to last match,
- overwriting what is there. */
- if (bytes_to_insert > 0)
+ /* Copy (new) chars to screen from first diff to last match */
+ temp = nls - nfd;
+ if (temp > 0)
{
/* If nfd begins at the prompt, or before the invisible
characters in the prompt, we need to adjust _rl_last_c_pos
in a multibyte locale to account for the wrap offset and
set cpos_adjusted accordingly. */
- _rl_output_some_chars (nfd, bytes_to_insert);
+ _rl_output_some_chars (nfd, temp);
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
{
- _rl_last_c_pos += _rl_col_width (nfd, 0, bytes_to_insert, 1);
- if (current_line == 0 && wrap_offset &&
- displaying_prompt_first_line &&
- _rl_last_c_pos > wrap_offset &&
- ((nfd - new) <= prompt_last_invisible))
+ _rl_last_c_pos += _rl_col_width (nfd, 0, temp, 1);
+ if (current_line == 0 && wrap_offset && ((nfd - new) <= prompt_last_invisible))
{
_rl_last_c_pos -= wrap_offset;
cpos_adjusted = 1;
}
}
else
- _rl_last_c_pos += bytes_to_insert;
-
- /* XXX - we only want to do this if we are at the end of the line
- so we move there with _rl_move_cursor_relative */
- if (_rl_horizontal_scroll_mode && ((oe-old) > (ne-new)))
- {
- _rl_move_cursor_relative (ne-new, new);
- goto clear_rest_of_line;
- }
+ _rl_last_c_pos += temp;
}
}
/* Otherwise, print over the existing material. */
_rl_last_c_pos += col_temp; /* XXX */
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
{
- if (current_line == 0 && wrap_offset &&
- displaying_prompt_first_line &&
- _rl_last_c_pos > wrap_offset &&
- ((nfd - new) <= prompt_last_invisible))
+ if (current_line == 0 && wrap_offset && ((nfd - new) <= prompt_last_invisible))
{
_rl_last_c_pos -= wrap_offset;
cpos_adjusted = 1;
}
}
}
-clear_rest_of_line:
lendiff = (oe - old) - (ne - new);
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
col_lendiff = _rl_col_width (old, 0, oe - old, 1) - _rl_col_width (new, 0, ne - new, 1);
else
col_lendiff = lendiff;
+#if 0
+ if (col_lendiff)
+#else
/* If we've already printed over the entire width of the screen,
including the old material, then col_lendiff doesn't matter and
space_to_eol will insert too many spaces. XXX - maybe we should
adjust col_lendiff based on the difference between _rl_last_c_pos
and _rl_screenwidth */
if (col_lendiff && ((MB_CUR_MAX == 1 || rl_byte_oriented) || (_rl_last_c_pos < _rl_screenwidth)))
+#endif
{
if (_rl_term_autowrap && current_line < inv_botlin)
space_to_eol (col_lendiff);
return 0;
}
-/* Redraw only the last line of a multi-line prompt. */
-void
-rl_redraw_prompt_last_line ()
-{
- char *t;
-
- t = strrchr (rl_display_prompt, '\n');
- if (t)
- redraw_prompt (++t);
- else
- rl_forced_update_display ();
-}
-
/* Move the cursor from _rl_last_c_pos to NEW, which are buffer indices.
(Well, when we don't have multibyte characters, _rl_last_c_pos is a
buffer index.)
else
dpos = _rl_col_width (data, 0, new, 1);
- if (displaying_prompt_first_line == 0)
- adjust = 0;
-
/* Use NEW when comparing against the last invisible character in the
prompt string, since they're both buffer indices and DPOS is a
desired display position. */
}
else
{ /* delta < 0 */
-#ifdef __DJGPP__
+#ifdef __MSDOS__
int row, col;
- fflush (rl_outstream);
+ fflush (rl_outstream); /* make sure the cursor pos is current! */
ScreenGetCursor (&row, &col);
ScreenSetCursor (row + delta, col);
- i = -delta;
-#else
+ i = -delta; /* in case someone wants to use it after the loop */
+#else /* !__MSDOS__ */
if (_rl_term_up && *_rl_term_up)
for (i = 0; i < -delta; i++)
tputs (_rl_term_up, 1, _rl_output_character_function);
-#endif /* !__DJGPP__ */
+#endif /* !__MSDOS__ */
}
_rl_last_v_pos = to; /* Now TO is here */
#if defined (PREFER_VARARGS)
char *format;
#endif
-#if defined (HAVE_VSNPRINTF)
- int bneed;
-#endif
#if defined (PREFER_STDARG)
va_start (args, format);
format = va_arg (args, char *);
#endif
- if (msg_buf == 0)
- msg_buf = xmalloc (msg_bufsiz = 128);
-
#if defined (HAVE_VSNPRINTF)
- bneed = vsnprintf (msg_buf, msg_bufsiz, format, args);
- if (bneed >= msg_bufsiz - 1)
- {
- msg_bufsiz = bneed + 1;
- msg_buf = xrealloc (msg_buf, msg_bufsiz);
- va_end (args);
-
-#if defined (PREFER_STDARG)
- va_start (args, format);
-#else
- va_start (args);
- format = va_arg (args, char *);
-#endif
- vsnprintf (msg_buf, msg_bufsiz - 1, format, args);
- }
+ vsnprintf (msg_buf, sizeof (msg_buf) - 1, format, args);
#else
vsprintf (msg_buf, format, args);
- msg_buf[msg_bufsiz - 1] = '\0'; /* overflow? */
+ msg_buf[sizeof(msg_buf) - 1] = '\0'; /* overflow? */
#endif
va_end (args);
rl_save_prompt ();
msg_saved_prompt = 1;
}
- else if (local_prompt != saved_local_prompt)
- {
- FREE (local_prompt);
- FREE (local_prompt_prefix);
- local_prompt = (char *)NULL;
- }
rl_display_prompt = msg_buf;
- local_prompt = expand_prompt (msg_buf, 0, &prompt_visible_length,
- &prompt_last_invisible,
- &prompt_invis_chars_first_line,
- &prompt_physical_chars);
+ local_prompt = expand_prompt (msg_buf, &prompt_visible_length,
+ &prompt_last_invisible,
+ &prompt_invis_chars_first_line,
+ &prompt_physical_chars);
local_prompt_prefix = (char *)NULL;
local_prompt_len = local_prompt ? strlen (local_prompt) : 0;
(*rl_redisplay_function) ();
rl_message (format, arg1, arg2)
char *format;
{
- if (msg_buf == 0)
- msg_buf = xmalloc (msg_bufsiz = 128);
-
sprintf (msg_buf, format, arg1, arg2);
- msg_buf[msg_bufsiz - 1] = '\0'; /* overflow? */
+ msg_buf[sizeof(msg_buf) - 1] = '\0'; /* overflow? */
rl_display_prompt = msg_buf;
if (saved_local_prompt == 0)
rl_save_prompt ();
msg_saved_prompt = 1;
}
- else if (local_prompt != saved_local_prompt)
- {
- FREE (local_prompt);
- FREE (local_prompt_prefix);
- local_prompt = (char *)NULL;
- }
- local_prompt = expand_prompt (msg_buf, 0, &prompt_visible_length,
- &prompt_last_invisible,
- &prompt_invis_chars_first_line,
- &prompt_physical_chars);
+ local_prompt = expand_prompt (msg_buf, &prompt_visible_length,
+ &prompt_last_invisible,
+ &prompt_invis_chars_first_line,
+ &prompt_physical_chars);
local_prompt_prefix = (char *)NULL;
local_prompt_len = local_prompt ? strlen (local_prompt) : 0;
(*rl_redisplay_function) ();
tputs (_rl_term_clreol, 1, _rl_output_character_function);
else
#endif
- if (count)
- space_to_eol (count);
+ if (count)
+ space_to_eol (count);
}
/* Clear to the end of the line using spaces. COUNT is the minimum
void
_rl_clear_screen ()
{
-#ifndef __DJGPP__
+#if defined (__GO32__)
+ ScreenClear (); /* FIXME: only works in text modes */
+ ScreenSetCursor (0, 0); /* term_clrpag is "cl" which homes the cursor */
+#else
if (_rl_term_clrpag)
tputs (_rl_term_clrpag, 1, _rl_output_character_function);
else
rl_crlf ();
-#else
- ScreenClear ();
- ScreenSetCursor (0, 0);
-#endif /* __DJGPP__ */
+#endif
}
/* Insert COUNT characters from STRING to the output stream at column COL. */
char *string;
int count, col;
{
- open_some_spaces (col);
+#if defined (__MSDOS__) || (defined (__MINGW32__) && !defined (NCURSES_VERSION))
_rl_output_some_chars (string, count);
-}
-
-/* Insert COL spaces, keeping the cursor at the same position. We follow the
- ncurses documentation and use either im/ei with explicit spaces, or IC/ic
- by itself. We assume there will either be ei or we don't need to use it. */
-static void
-open_some_spaces (col)
- int col;
-{
-#if !defined (__MSDOS__) && (!defined (__MINGW32__) || defined (NCURSES_VERSION))
- char *buffer;
- register int i;
+#else
+ /* DEBUGGING */
+ if (MB_CUR_MAX == 1 || rl_byte_oriented)
+ if (count != col)
+ _rl_ttymsg ("debug: insert_some_chars: count (%d) != col (%d)", count, col);
/* If IC is defined, then we do not have to "enter" insert mode. */
if (_rl_term_IC)
{
+ char *buffer;
+
buffer = tgoto (_rl_term_IC, 0, col);
tputs (buffer, 1, _rl_output_character_function);
+ _rl_output_some_chars (string, count);
}
- else if (_rl_term_im && *_rl_term_im)
- {
- tputs (_rl_term_im, 1, _rl_output_character_function);
- /* just output the desired number of spaces */
- for (i = col; i--; )
- _rl_output_character_function (' ');
- /* If there is a string to turn off insert mode, use it now. */
- if (_rl_term_ei && *_rl_term_ei)
- tputs (_rl_term_ei, 1, _rl_output_character_function);
- /* and move back the right number of spaces */
- _rl_backspace (col);
- }
- else if (_rl_term_ic && *_rl_term_ic)
+ else
{
+ register int i;
+
+ /* If we have to turn on insert-mode, then do so. */
+ if (_rl_term_im && *_rl_term_im)
+ tputs (_rl_term_im, 1, _rl_output_character_function);
+
/* If there is a special command for inserting characters, then
use that first to open up the space. */
- for (i = col; i--; )
- tputs (_rl_term_ic, 1, _rl_output_character_function);
+ if (_rl_term_ic && *_rl_term_ic)
+ {
+ for (i = col; i--; )
+ tputs (_rl_term_ic, 1, _rl_output_character_function);
+ }
+
+ /* Print the text. */
+ _rl_output_some_chars (string, count);
+
+ /* If there is a string to turn off insert mode, we had best use
+ it now. */
+ if (_rl_term_ei && *_rl_term_ei)
+ tputs (_rl_term_ei, 1, _rl_output_character_function);
}
-#endif /* !__MSDOS__ && (!__MINGW32__ || NCURSES_VERSION)*/
+#endif /* __MSDOS__ || __MINGW32__ */
}
/* Delete COUNT characters from the display line. */
if (count > _rl_screenwidth) /* XXX */
return;
-#if !defined (__MSDOS__) && (!defined (__MINGW32__) || defined (NCURSES_VERSION))
+#if !defined (__MSDOS__) && !(defined (__MINGW32__) && !defined (NCURSES_VERSION))
if (_rl_term_DC && *_rl_term_DC)
{
char *buffer;
while (count--)
tputs (_rl_term_dc, 1, _rl_output_character_function);
}
-#endif /* !__MSDOS__ && (!__MINGW32__ || NCURSES_VERSION)*/
+#endif /* !__MSDOS__ && !__MINGW32__ */
}
void
rl_save_prompt ();
rl_display_prompt = t;
- local_prompt = expand_prompt (t, PMT_MULTILINE,
- &prompt_visible_length,
+ local_prompt = expand_prompt (t, &prompt_visible_length,
&prompt_last_invisible,
&prompt_invis_chars_first_line,
&prompt_physical_chars);
{
if (_rl_echoing_p)
{
- if (_rl_vis_botlin > 0) /* minor optimization plus bug fix */
- _rl_move_vert (_rl_vis_botlin);
+ _rl_move_vert (_rl_vis_botlin);
_rl_vis_botlin = 0;
fflush (rl_outstream);
rl_restart_output (1, 0);
fflush (rl_outstream);
}
-void
-_rl_ttyflush ()
-{
- fflush (rl_outstream);
-}
-
/* return the `current display line' of the cursor -- the number of lines to
move up to get to the first screen line of the current readline line. */
int
if (end <= start)
return 0;
if (MB_CUR_MAX == 1 || rl_byte_oriented)
- /* this can happen in some cases where it's inconvenient to check */
+{
+_rl_ttymsg ("_rl_col_width: called with MB_CUR_MAX == 1");
return (end - start);
+}
memset (&ps, 0, sizeof (mbstate_t));
{
point += tmp;
max -= tmp;
- tmp = WCWIDTH(wc);
+ tmp = wcwidth(wc);
width += (tmp >= 0) ? tmp : 1;
}
}
projects / deliverable / binutils-gdb.git / blobdiff