Deleted Added
sdiff udiff text old ( 119614 ) new ( 136759 )
full compact
display.c (119614) display.c (136759)
1/* $FreeBSD: head/contrib/libreadline/display.c 119614 2003-08-31 18:29:38Z ache $ */
1/* $FreeBSD: head/contrib/libreadline/display.c 136759 2004-10-21 20:10:14Z peter $ */
2
2/* display.c -- readline redisplay facility. */
3
3/* display.c -- readline redisplay facility. */
4
4/* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc.
5/* Copyright (C) 1987-2004 Free Software Foundation, Inc.
5
6 This file is part of the GNU Readline Library, a library for
7 reading lines of text with interactive input and history editing.
8
9 The GNU Readline Library is free software; you can redistribute it
10 and/or modify it under the terms of the GNU General Public License
11 as published by the Free Software Foundation; either version 2, or
12 (at your option) any later version.

--- 53 unchanged lines hidden (view full) ---

66
67static void update_line PARAMS((char *, char *, int, int, int, int));
68static void space_to_eol PARAMS((int));
69static void delete_chars PARAMS((int));
70static void insert_some_chars PARAMS((char *, int, int));
71static void cr PARAMS((void));
72
73#if defined (HANDLE_MULTIBYTE)
6
7 This file is part of the GNU Readline Library, a library for
8 reading lines of text with interactive input and history editing.
9
10 The GNU Readline Library is free software; you can redistribute it
11 and/or modify it under the terms of the GNU General Public License
12 as published by the Free Software Foundation; either version 2, or
13 (at your option) any later version.

--- 53 unchanged lines hidden (view full) ---

67
68static void update_line PARAMS((char *, char *, int, int, int, int));
69static void space_to_eol PARAMS((int));
70static void delete_chars PARAMS((int));
71static void insert_some_chars PARAMS((char *, int, int));
72static void cr PARAMS((void));
73
74#if defined (HANDLE_MULTIBYTE)
74static int _rl_col_width PARAMS((char *, int, int));
75static int _rl_col_width PARAMS((const char *, int, int));
75static int *_rl_wrapped_line;
76#else
77# define _rl_col_width(l, s, e) (((e) <= (s)) ? 0 : (e) - (s))
78#endif
79
80static int *inv_lbreaks, *vis_lbreaks;
81static int inv_lbsize, vis_lbsize;
82

--- 91 unchanged lines hidden (view full) ---

174
175/* Number of invisible characters on the first physical line of the prompt.
176 Only valid when the number of physical characters in the prompt exceeds
177 (or is equal to) _rl_screenwidth. */
178static int prompt_invis_chars_first_line;
179
180static int prompt_last_screen_line;
181
76static int *_rl_wrapped_line;
77#else
78# define _rl_col_width(l, s, e) (((e) <= (s)) ? 0 : (e) - (s))
79#endif
80
81static int *inv_lbreaks, *vis_lbreaks;
82static int inv_lbsize, vis_lbsize;
83

--- 91 unchanged lines hidden (view full) ---

175
176/* Number of invisible characters on the first physical line of the prompt.
177 Only valid when the number of physical characters in the prompt exceeds
178 (or is equal to) _rl_screenwidth. */
179static int prompt_invis_chars_first_line;
180
181static int prompt_last_screen_line;
182
183static int prompt_physical_chars;
184
182/* Expand the prompt string S and return the number of visible
183 characters in *LP, if LP is not null. This is currently more-or-less
184 a placeholder for expansion. LIP, if non-null is a place to store the
185 index of the last invisible character in the returned string. NIFLP,
186 if non-zero, is a place to store the number of invisible characters in
185/* Expand the prompt string S and return the number of visible
186 characters in *LP, if LP is not null. This is currently more-or-less
187 a placeholder for expansion. LIP, if non-null is a place to store the
188 index of the last invisible character in the returned string. NIFLP,
189 if non-zero, is a place to store the number of invisible characters in
187 the first prompt line. */
190 the first prompt line. The previous are used as byte counts -- indexes
191 into a character buffer. */
188
189/* Current implementation:
190 \001 (^A) start non-visible characters
191 \002 (^B) end non-visible characters
192 all characters except \001 and \002 (following a \001) are copied to
193 the returned string; all characters except those between \001 and
194 \002 are assumed to be `visible'. */
195
196static char *
192
193/* Current implementation:
194 \001 (^A) start non-visible characters
195 \002 (^B) end non-visible characters
196 all characters except \001 and \002 (following a \001) are copied to
197 the returned string; all characters except those between \001 and
198 \002 are assumed to be `visible'. */
199
200static char *
197expand_prompt (pmt, lp, lip, niflp)
201expand_prompt (pmt, lp, lip, niflp, vlp)
198 char *pmt;
202 char *pmt;
199 int *lp, *lip, *niflp;
203 int *lp, *lip, *niflp, *vlp;
200{
201 char *r, *ret, *p;
204{
205 char *r, *ret, *p;
202 int l, rl, last, ignoring, ninvis, invfl;
206 int l, rl, last, ignoring, ninvis, invfl, invflset, ind, pind, physchars;
203
204 /* Short-circuit if we can. */
207
208 /* Short-circuit if we can. */
205 if (strchr (pmt, RL_PROMPT_START_IGNORE) == 0)
209 if ((MB_CUR_MAX <= 1 || rl_byte_oriented) && strchr (pmt, RL_PROMPT_START_IGNORE) == 0)
206 {
207 r = savestring (pmt);
208 if (lp)
209 *lp = strlen (r);
210 {
211 r = savestring (pmt);
212 if (lp)
213 *lp = strlen (r);
214 if (lip)
215 *lip = 0;
216 if (niflp)
217 *niflp = 0;
218 if (vlp)
219 *vlp = lp ? *lp : strlen (r);
210 return r;
211 }
212
213 l = strlen (pmt);
214 r = ret = (char *)xmalloc (l + 1);
215
216 invfl = 0; /* invisible chars in first line of prompt */
220 return r;
221 }
222
223 l = strlen (pmt);
224 r = ret = (char *)xmalloc (l + 1);
225
226 invfl = 0; /* invisible chars in first line of prompt */
227 invflset = 0; /* we only want to set invfl once */
217
228
218 for (rl = ignoring = last = ninvis = 0, p = pmt; p && *p; p++)
229 for (rl = ignoring = last = ninvis = physchars = 0, p = pmt; p && *p; p++)
219 {
220 /* This code strips the invisible character string markers
221 RL_PROMPT_START_IGNORE and RL_PROMPT_END_IGNORE */
222 if (*p == RL_PROMPT_START_IGNORE)
223 {
224 ignoring++;
225 continue;
226 }
227 else if (ignoring && *p == RL_PROMPT_END_IGNORE)
228 {
229 ignoring = 0;
230 last = r - ret - 1;
231 continue;
232 }
233 else
234 {
230 {
231 /* This code strips the invisible character string markers
232 RL_PROMPT_START_IGNORE and RL_PROMPT_END_IGNORE */
233 if (*p == RL_PROMPT_START_IGNORE)
234 {
235 ignoring++;
236 continue;
237 }
238 else if (ignoring && *p == RL_PROMPT_END_IGNORE)
239 {
240 ignoring = 0;
241 last = r - ret - 1;
242 continue;
243 }
244 else
245 {
235 *r++ = *p;
236 if (!ignoring)
237 rl++;
246#if defined (HANDLE_MULTIBYTE)
247 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
248 {
249 pind = p - pmt;
250 ind = _rl_find_next_mbchar (pmt, pind, 1, MB_FIND_NONZERO);
251 l = ind - pind;
252 while (l--)
253 *r++ = *p++;
254 if (!ignoring)
255 {
256 rl += ind - pind;
257 physchars += _rl_col_width (pmt, pind, ind);
258 }
259 else
260 ninvis += ind - pind;
261 p--; /* compensate for later increment */
262 }
238 else
263 else
239 ninvis++;
240 if (rl == _rl_screenwidth)
241 invfl = ninvis;
264#endif
265 {
266 *r++ = *p;
267 if (!ignoring)
268 {
269 rl++; /* visible length byte counter */
270 physchars++;
271 }
272 else
273 ninvis++; /* invisible chars byte counter */
274 }
275
276 if (invflset == 0 && rl >= _rl_screenwidth)
277 {
278 invfl = ninvis;
279 invflset = 1;
280 }
242 }
243 }
244
245 if (rl < _rl_screenwidth)
246 invfl = ninvis;
247
248 *r = '\0';
249 if (lp)
250 *lp = rl;
251 if (lip)
252 *lip = last;
253 if (niflp)
254 *niflp = invfl;
281 }
282 }
283
284 if (rl < _rl_screenwidth)
285 invfl = ninvis;
286
287 *r = '\0';
288 if (lp)
289 *lp = rl;
290 if (lip)
291 *lip = last;
292 if (niflp)
293 *niflp = invfl;
294 if (vlp)
295 *vlp = physchars;
255 return ret;
256}
257
258/* Just strip out RL_PROMPT_START_IGNORE and RL_PROMPT_END_IGNORE from
259 PMT and return the rest of PMT. */
260char *
261_rl_strip_prompt (pmt)
262 char *pmt;
263{
264 char *ret;
265
296 return ret;
297}
298
299/* Just strip out RL_PROMPT_START_IGNORE and RL_PROMPT_END_IGNORE from
300 PMT and return the rest of PMT. */
301char *
302_rl_strip_prompt (pmt)
303 char *pmt;
304{
305 char *ret;
306
266 ret = expand_prompt (pmt, (int *)NULL, (int *)NULL, (int *)NULL);
307 ret = expand_prompt (pmt, (int *)NULL, (int *)NULL, (int *)NULL, (int *)NULL);
267 return ret;
268}
269
270/*
271 * Expand the prompt string into the various display components, if
272 * necessary.
273 *
274 * local_prompt = expanded last line of string in rl_display_prompt

--- 27 unchanged lines hidden (view full) ---

302 return (0);
303
304 p = strrchr (prompt, '\n');
305 if (!p)
306 {
307 /* The prompt is only one logical line, though it might wrap. */
308 local_prompt = expand_prompt (prompt, &prompt_visible_length,
309 &prompt_last_invisible,
308 return ret;
309}
310
311/*
312 * Expand the prompt string into the various display components, if
313 * necessary.
314 *
315 * local_prompt = expanded last line of string in rl_display_prompt

--- 27 unchanged lines hidden (view full) ---

343 return (0);
344
345 p = strrchr (prompt, '\n');
346 if (!p)
347 {
348 /* The prompt is only one logical line, though it might wrap. */
349 local_prompt = expand_prompt (prompt, &prompt_visible_length,
350 &prompt_last_invisible,
310 &prompt_invis_chars_first_line);
351 &prompt_invis_chars_first_line,
352 &prompt_physical_chars);
311 local_prompt_prefix = (char *)0;
312 return (prompt_visible_length);
313 }
314 else
315 {
316 /* The prompt spans multiple lines. */
317 t = ++p;
318 local_prompt = expand_prompt (p, &prompt_visible_length,
319 &prompt_last_invisible,
353 local_prompt_prefix = (char *)0;
354 return (prompt_visible_length);
355 }
356 else
357 {
358 /* The prompt spans multiple lines. */
359 t = ++p;
360 local_prompt = expand_prompt (p, &prompt_visible_length,
361 &prompt_last_invisible,
320 &prompt_invis_chars_first_line);
362 (int *)NULL,
363 &prompt_physical_chars);
321 c = *t; *t = '\0';
322 /* The portion of the prompt string up to and including the
323 final newline is now null-terminated. */
324 local_prompt_prefix = expand_prompt (prompt, &prompt_prefix_length,
325 (int *)NULL,
364 c = *t; *t = '\0';
365 /* The portion of the prompt string up to and including the
366 final newline is now null-terminated. */
367 local_prompt_prefix = expand_prompt (prompt, &prompt_prefix_length,
368 (int *)NULL,
326 &prompt_invis_chars_first_line);
369 &prompt_invis_chars_first_line,
370 (int *)NULL);
327 *t = c;
328 return (prompt_prefix_length);
329 }
330}
331
332/* Initialize the VISIBLE_LINE and INVISIBLE_LINE arrays, and their associated
333 arrays of line break markers. MINSIZE is the minimum size of VISIBLE_LINE
334 and INVISIBLE_LINE; if it is greater than LINE_SIZE, LINE_SIZE is

--- 42 unchanged lines hidden (view full) ---

377
378/* Basic redisplay algorithm. */
379void
380rl_redisplay ()
381{
382 register int in, out, c, linenum, cursor_linenum;
383 register char *line;
384 int c_pos, inv_botlin, lb_botlin, lb_linenum;
371 *t = c;
372 return (prompt_prefix_length);
373 }
374}
375
376/* Initialize the VISIBLE_LINE and INVISIBLE_LINE arrays, and their associated
377 arrays of line break markers. MINSIZE is the minimum size of VISIBLE_LINE
378 and INVISIBLE_LINE; if it is greater than LINE_SIZE, LINE_SIZE is

--- 42 unchanged lines hidden (view full) ---

421
422/* Basic redisplay algorithm. */
423void
424rl_redisplay ()
425{
426 register int in, out, c, linenum, cursor_linenum;
427 register char *line;
428 int c_pos, inv_botlin, lb_botlin, lb_linenum;
385 int newlines, lpos, temp;
429 int newlines, lpos, temp, modmark, n0, num;
386 char *prompt_this_line;
387#if defined (HANDLE_MULTIBYTE)
388 wchar_t wc;
389 size_t wc_bytes;
390 int wc_width;
391 mbstate_t ps;
392 int _rl_wrapped_multicolumn = 0;
393#endif

--- 13 unchanged lines hidden (view full) ---

407 /* Draw the line into the buffer. */
408 c_pos = -1;
409
410 line = invisible_line;
411 out = inv_botlin = 0;
412
413 /* Mark the line as modified or not. We only do this for history
414 lines. */
430 char *prompt_this_line;
431#if defined (HANDLE_MULTIBYTE)
432 wchar_t wc;
433 size_t wc_bytes;
434 int wc_width;
435 mbstate_t ps;
436 int _rl_wrapped_multicolumn = 0;
437#endif

--- 13 unchanged lines hidden (view full) ---

451 /* Draw the line into the buffer. */
452 c_pos = -1;
453
454 line = invisible_line;
455 out = inv_botlin = 0;
456
457 /* Mark the line as modified or not. We only do this for history
458 lines. */
459 modmark = 0;
415 if (_rl_mark_modified_lines && current_history () && rl_undo_list)
416 {
417 line[out++] = '*';
418 line[out] = '\0';
460 if (_rl_mark_modified_lines && current_history () && rl_undo_list)
461 {
462 line[out++] = '*';
463 line[out] = '\0';
464 modmark = 1;
419 }
420
421 /* If someone thought that the redisplay was handled, but the currently
422 visible line has a different modification state than the one about
423 to become visible, then correct the caller's misconception. */
424 if (visible_line[0] != invisible_line[0])
425 rl_display_fixed = 0;
426

--- 37 unchanged lines hidden (view full) ---

464 _rl_output_some_chars (rl_display_prompt, pmtlen);
465 /* Make sure we are at column zero even after a newline,
466 regardless of the state of terminal output processing. */
467 if (pmtlen < 2 || prompt_this_line[-2] != '\r')
468 cr ();
469 }
470 }
471
465 }
466
467 /* If someone thought that the redisplay was handled, but the currently
468 visible line has a different modification state than the one about
469 to become visible, then correct the caller's misconception. */
470 if (visible_line[0] != invisible_line[0])
471 rl_display_fixed = 0;
472

--- 37 unchanged lines hidden (view full) ---

510 _rl_output_some_chars (rl_display_prompt, pmtlen);
511 /* Make sure we are at column zero even after a newline,
512 regardless of the state of terminal output processing. */
513 if (pmtlen < 2 || prompt_this_line[-2] != '\r')
514 cr ();
515 }
516 }
517
472 pmtlen = strlen (prompt_this_line);
518 prompt_physical_chars = pmtlen = strlen (prompt_this_line);
473 temp = pmtlen + out + 2;
474 if (temp >= line_size)
475 {
476 line_size = (temp + 1024) - (temp % 1024);
477 visible_line = (char *)xrealloc (visible_line, line_size);
478 line = invisible_line = (char *)xrealloc (invisible_line, line_size);
479 }
480 strncpy (line + out, prompt_this_line, pmtlen);

--- 42 unchanged lines hidden (view full) ---

523 inv_lbreaks[++newlines] = out; \
524 lpos = 0; \
525 } \
526 } while (0)
527#endif
528
529 /* inv_lbreaks[i] is where line i starts in the buffer. */
530 inv_lbreaks[newlines = 0] = 0;
519 temp = pmtlen + out + 2;
520 if (temp >= line_size)
521 {
522 line_size = (temp + 1024) - (temp % 1024);
523 visible_line = (char *)xrealloc (visible_line, line_size);
524 line = invisible_line = (char *)xrealloc (invisible_line, line_size);
525 }
526 strncpy (line + out, prompt_this_line, pmtlen);

--- 42 unchanged lines hidden (view full) ---

569 inv_lbreaks[++newlines] = out; \
570 lpos = 0; \
571 } \
572 } while (0)
573#endif
574
575 /* inv_lbreaks[i] is where line i starts in the buffer. */
576 inv_lbreaks[newlines = 0] = 0;
577#if 0
531 lpos = out - wrap_offset;
578 lpos = out - wrap_offset;
579#else
580 lpos = prompt_physical_chars + modmark;
581#endif
582
532#if defined (HANDLE_MULTIBYTE)
533 memset (_rl_wrapped_line, 0, vis_lbsize);
583#if defined (HANDLE_MULTIBYTE)
584 memset (_rl_wrapped_line, 0, vis_lbsize);
585 num = 0;
534#endif
535
536 /* prompt_invis_chars_first_line is the number of invisible characters in
537 the first physical line of the prompt.
538 wrap_offset - prompt_invis_chars_first_line is the number of invis
539 chars on the second line. */
540
541 /* what if lpos is already >= _rl_screenwidth before we start drawing the
542 contents of the command line? */
543 while (lpos >= _rl_screenwidth)
544 {
545 /* fix from Darin Johnson <darin@acuson.com> for prompt string with
546 invisible characters that is longer than the screen width. The
547 prompt_invis_chars_first_line variable could be made into an array
548 saying how many invisible characters there are per line, but that's
549 probably too much work for the benefit gained. How many people have
586#endif
587
588 /* prompt_invis_chars_first_line is the number of invisible characters in
589 the first physical line of the prompt.
590 wrap_offset - prompt_invis_chars_first_line is the number of invis
591 chars on the second line. */
592
593 /* what if lpos is already >= _rl_screenwidth before we start drawing the
594 contents of the command line? */
595 while (lpos >= _rl_screenwidth)
596 {
597 /* fix from Darin Johnson <darin@acuson.com> for prompt string with
598 invisible characters that is longer than the screen width. The
599 prompt_invis_chars_first_line variable could be made into an array
600 saying how many invisible characters there are per line, but that's
601 probably too much work for the benefit gained. How many people have
550 prompts that exceed two physical lines? */
551 temp = ((newlines + 1) * _rl_screenwidth) +
552#if 0
553 ((newlines == 0) ? prompt_invis_chars_first_line : 0) +
602 prompts that exceed two physical lines?
603 Additional logic fix from Edward Catmur <ed@catmur.co.uk> */
604#if defined (HANDLE_MULTIBYTE)
605 n0 = num;
606 temp = local_prompt ? strlen (local_prompt) : 0;
607 while (num < temp)
608 {
609 if (_rl_col_width (local_prompt, n0, num) > _rl_screenwidth)
610 {
611 num = _rl_find_prev_mbchar (local_prompt, num, MB_FIND_ANY);
612 break;
613 }
614 num++;
615 }
616 temp = num +
554#else
617#else
555 ((newlines == 0 && local_prompt_prefix == 0) ? prompt_invis_chars_first_line : 0) +
556#endif
557 ((newlines == 1) ? wrap_offset : 0);
558
618 temp = ((newlines + 1) * _rl_screenwidth) +
619#endif /* !HANDLE_MULTIBYTE */
620 ((local_prompt_prefix == 0) ? ((newlines == 0) ? prompt_invis_chars_first_line
621 : ((newlines == 1) ? wrap_offset : 0))
622 : ((newlines == 0) ? wrap_offset :0));
623
559 inv_lbreaks[++newlines] = temp;
624 inv_lbreaks[++newlines] = temp;
625#if defined (HANDLE_MULTIBYTE)
626 lpos -= _rl_col_width (local_prompt, n0, num);
627#else
560 lpos -= _rl_screenwidth;
628 lpos -= _rl_screenwidth;
629#endif
561 }
562
563 prompt_last_screen_line = newlines;
564
565 /* Draw the rest of the line (after the prompt) into invisible_line, keeping
566 track of where the cursor is (c_pos), the number of the line containing
567 the cursor (lb_linenum), the last line number (lb_botlin and inv_botlin).
568 It maintains an array of line breaks for display (inv_lbreaks).

--- 13 unchanged lines hidden (view full) ---

582 for (in = 0; in < rl_end; in++)
583#endif
584 {
585 c = (unsigned char)rl_line_buffer[in];
586
587#if defined (HANDLE_MULTIBYTE)
588 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
589 {
630 }
631
632 prompt_last_screen_line = newlines;
633
634 /* Draw the rest of the line (after the prompt) into invisible_line, keeping
635 track of where the cursor is (c_pos), the number of the line containing
636 the cursor (lb_linenum), the last line number (lb_botlin and inv_botlin).
637 It maintains an array of line breaks for display (inv_lbreaks).

--- 13 unchanged lines hidden (view full) ---

651 for (in = 0; in < rl_end; in++)
652#endif
653 {
654 c = (unsigned char)rl_line_buffer[in];
655
656#if defined (HANDLE_MULTIBYTE)
657 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
658 {
590 if (wc_bytes == (size_t)-1 || wc_bytes == (size_t)-2)
659 if (MB_INVALIDCH (wc_bytes))
591 {
592 /* Byte sequence is invalid or shortened. Assume that the
593 first byte represents a character. */
594 wc_bytes = 1;
595 /* Assume that a character occupies a single column. */
596 wc_width = 1;
597 memset (&ps, 0, sizeof (mbstate_t));
598 }
660 {
661 /* Byte sequence is invalid or shortened. Assume that the
662 first byte represents a character. */
663 wc_bytes = 1;
664 /* Assume that a character occupies a single column. */
665 wc_width = 1;
666 memset (&ps, 0, sizeof (mbstate_t));
667 }
599 else if (wc_bytes == (size_t)0)
668 else if (MB_NULLWCH (wc_bytes))
600 break; /* Found '\0' */
601 else
602 {
603 temp = wcwidth (wc);
669 break; /* Found '\0' */
670 else
671 {
672 temp = wcwidth (wc);
604 wc_width = (temp < 0) ? 1 : temp;
673 wc_width = (temp >= 0) ? temp : 1;
605 }
606 }
607#endif
608
609 if (out + 8 >= line_size) /* XXX - 8 for \t */
610 {
611 line_size *= 2;
612 visible_line = (char *)xrealloc (visible_line, line_size);

--- 250 unchanged lines hidden (view full) ---

863#if defined (__MSDOS__)
864 putc ('\r', rl_outstream);
865#else
866 if (_rl_term_cr)
867 tputs (_rl_term_cr, 1, _rl_output_character_function);
868#endif
869 _rl_output_some_chars (local_prompt, nleft);
870 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
674 }
675 }
676#endif
677
678 if (out + 8 >= line_size) /* XXX - 8 for \t */
679 {
680 line_size *= 2;
681 visible_line = (char *)xrealloc (visible_line, line_size);

--- 250 unchanged lines hidden (view full) ---

932#if defined (__MSDOS__)
933 putc ('\r', rl_outstream);
934#else
935 if (_rl_term_cr)
936 tputs (_rl_term_cr, 1, _rl_output_character_function);
937#endif
938 _rl_output_some_chars (local_prompt, nleft);
939 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
871 _rl_last_c_pos = _rl_col_width(local_prompt, 0, nleft);
940 _rl_last_c_pos = _rl_col_width (local_prompt, 0, nleft);
872 else
873 _rl_last_c_pos = nleft;
874 }
875
876 /* Where on that line? And where does that line start
877 in the buffer? */
878 pos = inv_lbreaks[cursor_linenum];
879 /* nleft == number of characters in the line buffer between the

--- 185 unchanged lines hidden (view full) ---

1065 /* This fixes only double-column characters, but if the wrapped
1066 character comsumes more than three columns, spaces will be
1067 inserted in the string buffer. */
1068 if (_rl_wrapped_line[current_line] > 0)
1069 _rl_clear_to_eol (_rl_wrapped_line[current_line]);
1070
1071 memset (&ps, 0, sizeof (mbstate_t));
1072 ret = mbrtowc (&wc, new, MB_CUR_MAX, &ps);
941 else
942 _rl_last_c_pos = nleft;
943 }
944
945 /* Where on that line? And where does that line start
946 in the buffer? */
947 pos = inv_lbreaks[cursor_linenum];
948 /* nleft == number of characters in the line buffer between the

--- 185 unchanged lines hidden (view full) ---

1134 /* This fixes only double-column characters, but if the wrapped
1135 character comsumes more than three columns, spaces will be
1136 inserted in the string buffer. */
1137 if (_rl_wrapped_line[current_line] > 0)
1138 _rl_clear_to_eol (_rl_wrapped_line[current_line]);
1139
1140 memset (&ps, 0, sizeof (mbstate_t));
1141 ret = mbrtowc (&wc, new, MB_CUR_MAX, &ps);
1073 if (ret == (size_t)-1 || ret == (size_t)-2)
1142 if (MB_INVALIDCH (ret))
1074 {
1075 tempwidth = 1;
1076 ret = 1;
1077 }
1143 {
1144 tempwidth = 1;
1145 ret = 1;
1146 }
1078 else if (ret == 0)
1147 else if (MB_NULLWCH (ret))
1079 tempwidth = 0;
1080 else
1081 tempwidth = wcwidth (wc);
1082
1083 if (tempwidth > 0)
1084 {
1085 int count;
1086 bytes = ret;
1087 for (count = 0; count < bytes; count++)
1088 putc (new[count], rl_outstream);
1089 _rl_last_c_pos = tempwidth;
1090 _rl_last_v_pos++;
1091 memset (&ps, 0, sizeof (mbstate_t));
1092 ret = mbrtowc (&wc, old, MB_CUR_MAX, &ps);
1093 if (ret != 0 && bytes != 0)
1094 {
1148 tempwidth = 0;
1149 else
1150 tempwidth = wcwidth (wc);
1151
1152 if (tempwidth > 0)
1153 {
1154 int count;
1155 bytes = ret;
1156 for (count = 0; count < bytes; count++)
1157 putc (new[count], rl_outstream);
1158 _rl_last_c_pos = tempwidth;
1159 _rl_last_v_pos++;
1160 memset (&ps, 0, sizeof (mbstate_t));
1161 ret = mbrtowc (&wc, old, MB_CUR_MAX, &ps);
1162 if (ret != 0 && bytes != 0)
1163 {
1095 if (ret == (size_t)-1 || ret == (size_t)-2)
1164 if (MB_INVALIDCH (ret))
1096 memmove (old+bytes, old+1, strlen (old+1));
1097 else
1098 memmove (old+bytes, old+ret, strlen (old+ret));
1099 memcpy (old, new, bytes);
1100 }
1101 }
1102 else
1103 {

--- 18 unchanged lines hidden (view full) ---

1122 }
1123 }
1124
1125
1126 /* Find first difference. */
1127#if defined (HANDLE_MULTIBYTE)
1128 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1129 {
1165 memmove (old+bytes, old+1, strlen (old+1));
1166 else
1167 memmove (old+bytes, old+ret, strlen (old+ret));
1168 memcpy (old, new, bytes);
1169 }
1170 }
1171 else
1172 {

--- 18 unchanged lines hidden (view full) ---

1191 }
1192 }
1193
1194
1195 /* Find first difference. */
1196#if defined (HANDLE_MULTIBYTE)
1197 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1198 {
1130 memset (&ps_new, 0, sizeof(mbstate_t));
1131 memset (&ps_old, 0, sizeof(mbstate_t));
1132
1133 new_offset = old_offset = 0;
1134 for (ofd = old, nfd = new;
1135 (ofd - old < omax) && *ofd &&
1136 _rl_compare_chars(old, old_offset, &ps_old, new, new_offset, &ps_new); )
1199 /* See if the old line is a subset of the new line, so that the
1200 only change is adding characters. */
1201 temp = (omax < nmax) ? omax : nmax;
1202 if (memcmp (old, new, temp) == 0)
1137 {
1203 {
1138 old_offset = _rl_find_next_mbchar (old, old_offset, 1, MB_FIND_ANY);
1139 new_offset = _rl_find_next_mbchar (new, new_offset, 1, MB_FIND_ANY);
1140 ofd = old + old_offset;
1141 nfd = new + new_offset;
1204 ofd = old + temp;
1205 nfd = new + temp;
1142 }
1206 }
1207 else
1208 {
1209 memset (&ps_new, 0, sizeof(mbstate_t));
1210 memset (&ps_old, 0, sizeof(mbstate_t));
1211
1212 if (omax == nmax && STREQN (new, old, omax))
1213 {
1214 ofd = old + omax;
1215 nfd = new + nmax;
1216 }
1217 else
1218 {
1219 new_offset = old_offset = 0;
1220 for (ofd = old, nfd = new;
1221 (ofd - old < omax) && *ofd &&
1222 _rl_compare_chars(old, old_offset, &ps_old, new, new_offset, &ps_new); )
1223 {
1224 old_offset = _rl_find_next_mbchar (old, old_offset, 1, MB_FIND_ANY);
1225 new_offset = _rl_find_next_mbchar (new, new_offset, 1, MB_FIND_ANY);
1226 ofd = old + old_offset;
1227 nfd = new + new_offset;
1228 }
1229 }
1230 }
1143 }
1144 else
1145#endif
1146 for (ofd = old, nfd = new;
1147 (ofd - old < omax) && *ofd && (*ofd == *nfd);
1148 ofd++, nfd++)
1149 ;
1150

--- 14 unchanged lines hidden (view full) ---

1165 {
1166 ols = old + _rl_find_prev_mbchar (old, oe - old, MB_FIND_ANY);
1167 nls = new + _rl_find_prev_mbchar (new, ne - new, MB_FIND_ANY);
1168 while ((ols > ofd) && (nls > nfd))
1169 {
1170 memset (&ps_old, 0, sizeof (mbstate_t));
1171 memset (&ps_new, 0, sizeof (mbstate_t));
1172
1231 }
1232 else
1233#endif
1234 for (ofd = old, nfd = new;
1235 (ofd - old < omax) && *ofd && (*ofd == *nfd);
1236 ofd++, nfd++)
1237 ;
1238

--- 14 unchanged lines hidden (view full) ---

1253 {
1254 ols = old + _rl_find_prev_mbchar (old, oe - old, MB_FIND_ANY);
1255 nls = new + _rl_find_prev_mbchar (new, ne - new, MB_FIND_ANY);
1256 while ((ols > ofd) && (nls > nfd))
1257 {
1258 memset (&ps_old, 0, sizeof (mbstate_t));
1259 memset (&ps_new, 0, sizeof (mbstate_t));
1260
1261#if 0
1262 /* On advice from jir@yamato.ibm.com */
1173 _rl_adjust_point (old, ols - old, &ps_old);
1174 _rl_adjust_point (new, nls - new, &ps_new);
1263 _rl_adjust_point (old, ols - old, &ps_old);
1264 _rl_adjust_point (new, nls - new, &ps_new);
1265#endif
1175
1176 if (_rl_compare_chars (old, ols - old, &ps_old, new, nls - new, &ps_new) == 0)
1177 break;
1178
1179 if (*ols == ' ')
1180 wsatend = 0;
1181
1182 ols = old + _rl_find_prev_mbchar (old, ols - old, MB_FIND_ANY);

--- 137 unchanged lines hidden (view full) ---

1320 _rl_term_IC or _rl_term_ic will screw up the screen because of the
1321 invisible characters. We need to just draw them. */
1322 if (*ols && (!_rl_horizontal_scroll_mode || _rl_last_c_pos > 0 ||
1323 lendiff <= prompt_visible_length || !current_invis_chars))
1324 {
1325 insert_some_chars (nfd, lendiff, col_lendiff);
1326 _rl_last_c_pos += col_lendiff;
1327 }
1266
1267 if (_rl_compare_chars (old, ols - old, &ps_old, new, nls - new, &ps_new) == 0)
1268 break;
1269
1270 if (*ols == ' ')
1271 wsatend = 0;
1272
1273 ols = old + _rl_find_prev_mbchar (old, ols - old, MB_FIND_ANY);

--- 137 unchanged lines hidden (view full) ---

1411 _rl_term_IC or _rl_term_ic will screw up the screen because of the
1412 invisible characters. We need to just draw them. */
1413 if (*ols && (!_rl_horizontal_scroll_mode || _rl_last_c_pos > 0 ||
1414 lendiff <= prompt_visible_length || !current_invis_chars))
1415 {
1416 insert_some_chars (nfd, lendiff, col_lendiff);
1417 _rl_last_c_pos += col_lendiff;
1418 }
1328 else if (*ols == 0)
1419 else if (*ols == 0 && lendiff > 0)
1329 {
1330 /* At the end of a line the characters do not have to
1331 be "inserted". They can just be placed on the screen. */
1332 /* However, this screws up the rest of this block, which
1333 assumes you've done the insert because you can. */
1334 _rl_output_some_chars (nfd, lendiff);
1335 _rl_last_c_pos += col_lendiff;
1336 }

--- 6 unchanged lines hidden (view full) ---

1343 _rl_last_c_pos += col_temp;
1344 return;
1345 }
1346 /* Copy (new) chars to screen from first diff to last match. */
1347 temp = nls - nfd;
1348 if ((temp - lendiff) > 0)
1349 {
1350 _rl_output_some_chars (nfd + lendiff, temp - lendiff);
1420 {
1421 /* At the end of a line the characters do not have to
1422 be "inserted". They can just be placed on the screen. */
1423 /* However, this screws up the rest of this block, which
1424 assumes you've done the insert because you can. */
1425 _rl_output_some_chars (nfd, lendiff);
1426 _rl_last_c_pos += col_lendiff;
1427 }

--- 6 unchanged lines hidden (view full) ---

1434 _rl_last_c_pos += col_temp;
1435 return;
1436 }
1437 /* Copy (new) chars to screen from first diff to last match. */
1438 temp = nls - nfd;
1439 if ((temp - lendiff) > 0)
1440 {
1441 _rl_output_some_chars (nfd + lendiff, temp - lendiff);
1351#if 0
1352 _rl_last_c_pos += _rl_col_width (nfd+lendiff, 0, temp-lendiff) - col_lendiff;
1353#else
1442#if 1
1443 /* XXX -- this bears closer inspection. Fixes a redisplay bug
1444 reported against bash-3.0-alpha by Andreas Schwab involving
1445 multibyte characters and prompt strings with invisible
1446 characters, but was previously disabled. */
1354 _rl_last_c_pos += _rl_col_width (nfd+lendiff, 0, temp-col_lendiff);
1447 _rl_last_c_pos += _rl_col_width (nfd+lendiff, 0, temp-col_lendiff);
1448#else
1449 _rl_last_c_pos += _rl_col_width (nfd+lendiff, 0, temp-lendiff);
1355#endif
1356 }
1357 }
1358 else
1359 {
1360 /* cannot insert chars, write to EOL */
1361 _rl_output_some_chars (nfd, temp);
1362 _rl_last_c_pos += col_temp;

--- 59 unchanged lines hidden (view full) ---

1422 if (vis_lbreaks)
1423 vis_lbreaks[0] = vis_lbreaks[1] = 0;
1424 visible_wrap_offset = 0;
1425 return 0;
1426}
1427
1428/* Tell the update routines that we have moved onto a new line with the
1429 prompt already displayed. Code originally from the version of readline
1450#endif
1451 }
1452 }
1453 else
1454 {
1455 /* cannot insert chars, write to EOL */
1456 _rl_output_some_chars (nfd, temp);
1457 _rl_last_c_pos += col_temp;

--- 59 unchanged lines hidden (view full) ---

1517 if (vis_lbreaks)
1518 vis_lbreaks[0] = vis_lbreaks[1] = 0;
1519 visible_wrap_offset = 0;
1520 return 0;
1521}
1522
1523/* Tell the update routines that we have moved onto a new line with the
1524 prompt already displayed. Code originally from the version of readline
1430 distributed with CLISP. */
1525 distributed with CLISP. rl_expand_prompt must have already been called
1526 (explicitly or implicitly). This still doesn't work exactly right. */
1431int
1432rl_on_new_line_with_prompt ()
1433{
1434 int prompt_size, i, l, real_screenwidth, newlines;
1527int
1528rl_on_new_line_with_prompt ()
1529{
1530 int prompt_size, i, l, real_screenwidth, newlines;
1435 char *prompt_last_line;
1531 char *prompt_last_line, *lprompt;
1436
1437 /* Initialize visible_line and invisible_line to ensure that they can hold
1438 the already-displayed prompt. */
1439 prompt_size = strlen (rl_prompt) + 1;
1440 init_line_structures (prompt_size);
1441
1442 /* Make sure the line structures hold the already-displayed prompt for
1443 redisplay. */
1532
1533 /* Initialize visible_line and invisible_line to ensure that they can hold
1534 the already-displayed prompt. */
1535 prompt_size = strlen (rl_prompt) + 1;
1536 init_line_structures (prompt_size);
1537
1538 /* Make sure the line structures hold the already-displayed prompt for
1539 redisplay. */
1444 strcpy (visible_line, rl_prompt);
1445 strcpy (invisible_line, rl_prompt);
1540 lprompt = local_prompt ? local_prompt : rl_prompt;
1541 strcpy (visible_line, lprompt);
1542 strcpy (invisible_line, lprompt);
1446
1447 /* If the prompt contains newlines, take the last tail. */
1448 prompt_last_line = strrchr (rl_prompt, '\n');
1449 if (!prompt_last_line)
1450 prompt_last_line = rl_prompt;
1451
1452 l = strlen (prompt_last_line);
1453 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)

--- 18 unchanged lines hidden (view full) ---

1472 {
1473 _rl_vis_botlin = newlines;
1474 vis_lbreaks[newlines++] = i;
1475 i += real_screenwidth;
1476 }
1477 vis_lbreaks[newlines] = l;
1478 visible_wrap_offset = 0;
1479
1543
1544 /* If the prompt contains newlines, take the last tail. */
1545 prompt_last_line = strrchr (rl_prompt, '\n');
1546 if (!prompt_last_line)
1547 prompt_last_line = rl_prompt;
1548
1549 l = strlen (prompt_last_line);
1550 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)

--- 18 unchanged lines hidden (view full) ---

1569 {
1570 _rl_vis_botlin = newlines;
1571 vis_lbreaks[newlines++] = i;
1572 i += real_screenwidth;
1573 }
1574 vis_lbreaks[newlines] = l;
1575 visible_wrap_offset = 0;
1576
1577 rl_display_prompt = rl_prompt; /* XXX - make sure it's set */
1578
1480 return 0;
1481}
1482
1483/* Actually update the display, period. */
1484int
1485rl_forced_update_display ()
1486{
1487 if (visible_line)

--- 18 unchanged lines hidden (view full) ---

1506 const char *data;
1507{
1508 register int i;
1509
1510 /* If we don't have to do anything, then return. */
1511#if defined (HANDLE_MULTIBYTE)
1512 /* If we have multibyte characters, NEW is indexed by the buffer point in
1513 a multibyte string, but _rl_last_c_pos is the display position. In
1579 return 0;
1580}
1581
1582/* Actually update the display, period. */
1583int
1584rl_forced_update_display ()
1585{
1586 if (visible_line)

--- 18 unchanged lines hidden (view full) ---

1605 const char *data;
1606{
1607 register int i;
1608
1609 /* If we don't have to do anything, then return. */
1610#if defined (HANDLE_MULTIBYTE)
1611 /* If we have multibyte characters, NEW is indexed by the buffer point in
1612 a multibyte string, but _rl_last_c_pos is the display position. In
1514 this case, NEW's display position is not obvious. */
1515 if ((MB_CUR_MAX == 1 || rl_byte_oriented ) && _rl_last_c_pos == new) return;
1613 this case, NEW's display position is not obvious and must be
1614 calculated. */
1615 if (MB_CUR_MAX == 1 || rl_byte_oriented)
1616 {
1617 if (_rl_last_c_pos == new)
1618 return;
1619 }
1620 else if (_rl_last_c_pos == _rl_col_width (data, 0, new))
1621 return;
1516#else
1517 if (_rl_last_c_pos == new) return;
1518#endif
1519
1520 /* It may be faster to output a CR, and then move forwards instead
1521 of moving backwards. */
1522 /* i == current physical cursor position. */
1523 i = _rl_last_c_pos - W_OFFSET(_rl_last_v_pos, visible_wrap_offset);

--- 66 unchanged lines hidden (view full) ---

1590 of the string, which means that if NEW == _rl_last_c_pos, then NEW's
1591 display point is less than _rl_last_c_pos. */
1592 else if (_rl_last_c_pos >= new)
1593#else
1594 else if (_rl_last_c_pos > new)
1595#endif
1596 {
1597 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1622#else
1623 if (_rl_last_c_pos == new) return;
1624#endif
1625
1626 /* It may be faster to output a CR, and then move forwards instead
1627 of moving backwards. */
1628 /* i == current physical cursor position. */
1629 i = _rl_last_c_pos - W_OFFSET(_rl_last_v_pos, visible_wrap_offset);

--- 66 unchanged lines hidden (view full) ---

1696 of the string, which means that if NEW == _rl_last_c_pos, then NEW's
1697 display point is less than _rl_last_c_pos. */
1698 else if (_rl_last_c_pos >= new)
1699#else
1700 else if (_rl_last_c_pos > new)
1701#endif
1702 {
1703 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1598 {
1599 tputs (_rl_term_cr, 1, _rl_output_character_function);
1600 for (i = 0; i < new; i++)
1601 putc (data[i], rl_outstream);
1602 }
1704 _rl_backspace (_rl_last_c_pos - _rl_col_width (data, 0, new));
1603 else
1604 _rl_backspace (_rl_last_c_pos - new);
1605 }
1606
1607 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1608 _rl_last_c_pos = _rl_col_width (data, 0, new);
1609 else
1610 _rl_last_c_pos = new;

--- 149 unchanged lines hidden (view full) ---

1760{
1761 rl_on_new_line ();
1762
1763 rl_display_prompt = rl_prompt ? rl_prompt : "";
1764 forced_display = 1;
1765 return 0;
1766}
1767
1705 else
1706 _rl_backspace (_rl_last_c_pos - new);
1707 }
1708
1709 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1710 _rl_last_c_pos = _rl_col_width (data, 0, new);
1711 else
1712 _rl_last_c_pos = new;

--- 149 unchanged lines hidden (view full) ---

1862{
1863 rl_on_new_line ();
1864
1865 rl_display_prompt = rl_prompt ? rl_prompt : "";
1866 forced_display = 1;
1867 return 0;
1868}
1869
1870/* These are getting numerous enough that it's time to create a struct. */
1871
1768static char *saved_local_prompt;
1769static char *saved_local_prefix;
1770static int saved_last_invisible;
1771static int saved_visible_length;
1872static char *saved_local_prompt;
1873static char *saved_local_prefix;
1874static int saved_last_invisible;
1875static int saved_visible_length;
1876static int saved_invis_chars_first_line;
1877static int saved_physical_chars;
1772
1773void
1774rl_save_prompt ()
1775{
1776 saved_local_prompt = local_prompt;
1777 saved_local_prefix = local_prompt_prefix;
1778 saved_last_invisible = prompt_last_invisible;
1779 saved_visible_length = prompt_visible_length;
1878
1879void
1880rl_save_prompt ()
1881{
1882 saved_local_prompt = local_prompt;
1883 saved_local_prefix = local_prompt_prefix;
1884 saved_last_invisible = prompt_last_invisible;
1885 saved_visible_length = prompt_visible_length;
1886 saved_invis_chars_first_line = prompt_invis_chars_first_line;
1887 saved_physical_chars = prompt_physical_chars;
1780
1781 local_prompt = local_prompt_prefix = (char *)0;
1782 prompt_last_invisible = prompt_visible_length = 0;
1888
1889 local_prompt = local_prompt_prefix = (char *)0;
1890 prompt_last_invisible = prompt_visible_length = 0;
1891 prompt_invis_chars_first_line = prompt_physical_chars = 0;
1783}
1784
1785void
1786rl_restore_prompt ()
1787{
1788 FREE (local_prompt);
1789 FREE (local_prompt_prefix);
1790
1791 local_prompt = saved_local_prompt;
1792 local_prompt_prefix = saved_local_prefix;
1793 prompt_last_invisible = saved_last_invisible;
1794 prompt_visible_length = saved_visible_length;
1892}
1893
1894void
1895rl_restore_prompt ()
1896{
1897 FREE (local_prompt);
1898 FREE (local_prompt_prefix);
1899
1900 local_prompt = saved_local_prompt;
1901 local_prompt_prefix = saved_local_prefix;
1902 prompt_last_invisible = saved_last_invisible;
1903 prompt_visible_length = saved_visible_length;
1904 prompt_invis_chars_first_line = saved_invis_chars_first_line;
1905 prompt_physical_chars = saved_physical_chars;
1795}
1796
1797char *
1798_rl_make_prompt_for_search (pchar)
1799 int pchar;
1800{
1801 int len;
1802 char *pmt;

--- 16 unchanged lines hidden (view full) ---

1819 if (len)
1820 strcpy (pmt, saved_local_prompt);
1821 pmt[len] = pchar;
1822 pmt[len+1] = '\0';
1823 local_prompt = savestring (pmt);
1824 prompt_last_invisible = saved_last_invisible;
1825 prompt_visible_length = saved_visible_length + 1;
1826 }
1906}
1907
1908char *
1909_rl_make_prompt_for_search (pchar)
1910 int pchar;
1911{
1912 int len;
1913 char *pmt;

--- 16 unchanged lines hidden (view full) ---

1930 if (len)
1931 strcpy (pmt, saved_local_prompt);
1932 pmt[len] = pchar;
1933 pmt[len+1] = '\0';
1934 local_prompt = savestring (pmt);
1935 prompt_last_invisible = saved_last_invisible;
1936 prompt_visible_length = saved_visible_length + 1;
1937 }
1938
1827 return pmt;
1828}
1829
1830/* Quick redisplay hack when erasing characters at the end of the line. */
1831void
1832_rl_erase_at_end_of_line (l)
1833 int l;
1834{

--- 160 unchanged lines hidden (view full) ---

1995/* Redraw the last line of a multi-line prompt that may possibly contain
1996 terminal escape sequences. Called with the cursor at column 0 of the
1997 line to draw the prompt on. */
1998static void
1999redraw_prompt (t)
2000 char *t;
2001{
2002 char *oldp, *oldl, *oldlprefix;
1939 return pmt;
1940}
1941
1942/* Quick redisplay hack when erasing characters at the end of the line. */
1943void
1944_rl_erase_at_end_of_line (l)
1945 int l;
1946{

--- 160 unchanged lines hidden (view full) ---

2107/* Redraw the last line of a multi-line prompt that may possibly contain
2108 terminal escape sequences. Called with the cursor at column 0 of the
2109 line to draw the prompt on. */
2110static void
2111redraw_prompt (t)
2112 char *t;
2113{
2114 char *oldp, *oldl, *oldlprefix;
2003 int oldlen, oldlast, oldplen, oldninvis;
2115 int oldlen, oldlast, oldplen, oldninvis, oldphyschars;
2004
2005 /* Geez, I should make this a struct. */
2006 oldp = rl_display_prompt;
2007 oldl = local_prompt;
2008 oldlprefix = local_prompt_prefix;
2009 oldlen = prompt_visible_length;
2010 oldplen = prompt_prefix_length;
2011 oldlast = prompt_last_invisible;
2012 oldninvis = prompt_invis_chars_first_line;
2116
2117 /* Geez, I should make this a struct. */
2118 oldp = rl_display_prompt;
2119 oldl = local_prompt;
2120 oldlprefix = local_prompt_prefix;
2121 oldlen = prompt_visible_length;
2122 oldplen = prompt_prefix_length;
2123 oldlast = prompt_last_invisible;
2124 oldninvis = prompt_invis_chars_first_line;
2125 oldphyschars = prompt_physical_chars;
2013
2014 rl_display_prompt = t;
2015 local_prompt = expand_prompt (t, &prompt_visible_length,
2016 &prompt_last_invisible,
2126
2127 rl_display_prompt = t;
2128 local_prompt = expand_prompt (t, &prompt_visible_length,
2129 &prompt_last_invisible,
2017 &prompt_invis_chars_first_line);
2130 &prompt_invis_chars_first_line,
2131 &prompt_physical_chars);
2018 local_prompt_prefix = (char *)NULL;
2019 rl_forced_update_display ();
2020
2021 rl_display_prompt = oldp;
2022 local_prompt = oldl;
2023 local_prompt_prefix = oldlprefix;
2024 prompt_visible_length = oldlen;
2025 prompt_prefix_length = oldplen;
2026 prompt_last_invisible = oldlast;
2027 prompt_invis_chars_first_line = oldninvis;
2132 local_prompt_prefix = (char *)NULL;
2133 rl_forced_update_display ();
2134
2135 rl_display_prompt = oldp;
2136 local_prompt = oldl;
2137 local_prompt_prefix = oldlprefix;
2138 prompt_visible_length = oldlen;
2139 prompt_prefix_length = oldplen;
2140 prompt_last_invisible = oldlast;
2141 prompt_invis_chars_first_line = oldninvis;
2142 prompt_physical_chars = oldphyschars;
2028}
2029
2030/* Redisplay the current line after a SIGWINCH is received. */
2031void
2032_rl_redisplay_after_sigwinch ()
2033{
2034 char *t;
2035

--- 77 unchanged lines hidden (view full) ---

2113}
2114
2115#if defined (HANDLE_MULTIBYTE)
2116/* Calculate the number of screen columns occupied by STR from START to END.
2117 In the case of multibyte characters with stateful encoding, we have to
2118 scan from the beginning of the string to take the state into account. */
2119static int
2120_rl_col_width (str, start, end)
2143}
2144
2145/* Redisplay the current line after a SIGWINCH is received. */
2146void
2147_rl_redisplay_after_sigwinch ()
2148{
2149 char *t;
2150

--- 77 unchanged lines hidden (view full) ---

2228}
2229
2230#if defined (HANDLE_MULTIBYTE)
2231/* Calculate the number of screen columns occupied by STR from START to END.
2232 In the case of multibyte characters with stateful encoding, we have to
2233 scan from the beginning of the string to take the state into account. */
2234static int
2235_rl_col_width (str, start, end)
2121 char *str;
2236 const char *str;
2122 int start, end;
2123{
2124 wchar_t wc;
2125 mbstate_t ps = {0};
2126 int tmp, point, width, max;
2127
2128 if (end <= start)
2129 return 0;
2130
2131 point = 0;
2132 max = end;
2133
2134 while (point < start)
2135 {
2136 tmp = mbrlen (str + point, max, &ps);
2237 int start, end;
2238{
2239 wchar_t wc;
2240 mbstate_t ps = {0};
2241 int tmp, point, width, max;
2242
2243 if (end <= start)
2244 return 0;
2245
2246 point = 0;
2247 max = end;
2248
2249 while (point < start)
2250 {
2251 tmp = mbrlen (str + point, max, &ps);
2137 if ((size_t)tmp == (size_t)-1 || (size_t)tmp == (size_t)-2)
2252 if (MB_INVALIDCH ((size_t)tmp))
2138 {
2139 /* In this case, the bytes are invalid or too short to compose a
2140 multibyte character, so we assume that the first byte represents
2141 a single character. */
2142 point++;
2143 max--;
2144
2145 /* Clear the state of the byte sequence, because in this case the
2146 effect of mbstate is undefined. */
2147 memset (&ps, 0, sizeof (mbstate_t));
2148 }
2253 {
2254 /* In this case, the bytes are invalid or too short to compose a
2255 multibyte character, so we assume that the first byte represents
2256 a single character. */
2257 point++;
2258 max--;
2259
2260 /* Clear the state of the byte sequence, because in this case the
2261 effect of mbstate is undefined. */
2262 memset (&ps, 0, sizeof (mbstate_t));
2263 }
2149 else if (tmp == 0)
2150 break; /* Found '\0' */
2264 else if (MB_NULLWCH (tmp))
2265 break; /* Found '\0' */
2151 else
2152 {
2153 point += tmp;
2154 max -= tmp;
2155 }
2156 }
2157
2158 /* If START is not a byte that starts a character, then POINT will be
2159 greater than START. In this case, assume that (POINT - START) gives
2160 a byte count that is the number of columns of difference. */
2161 width = point - start;
2162
2163 while (point < end)
2164 {
2165 tmp = mbrtowc (&wc, str + point, max, &ps);
2266 else
2267 {
2268 point += tmp;
2269 max -= tmp;
2270 }
2271 }
2272
2273 /* If START is not a byte that starts a character, then POINT will be
2274 greater than START. In this case, assume that (POINT - START) gives
2275 a byte count that is the number of columns of difference. */
2276 width = point - start;
2277
2278 while (point < end)
2279 {
2280 tmp = mbrtowc (&wc, str + point, max, &ps);
2166 if ((size_t)tmp == (size_t)-1 || (size_t)tmp == (size_t)-2)
2281 if (MB_INVALIDCH ((size_t)tmp))
2167 {
2168 /* In this case, the bytes are invalid or too short to compose a
2169 multibyte character, so we assume that the first byte represents
2170 a single character. */
2171 point++;
2172 max--;
2173
2174 /* and assume that the byte occupies a single column. */
2175 width++;
2176
2177 /* Clear the state of the byte sequence, because in this case the
2178 effect of mbstate is undefined. */
2179 memset (&ps, 0, sizeof (mbstate_t));
2180 }
2282 {
2283 /* In this case, the bytes are invalid or too short to compose a
2284 multibyte character, so we assume that the first byte represents
2285 a single character. */
2286 point++;
2287 max--;
2288
2289 /* and assume that the byte occupies a single column. */
2290 width++;
2291
2292 /* Clear the state of the byte sequence, because in this case the
2293 effect of mbstate is undefined. */
2294 memset (&ps, 0, sizeof (mbstate_t));
2295 }
2181 else if (tmp == 0)
2182 break; /* Found '\0' */
2296 else if (MB_NULLWCH (tmp))
2297 break; /* Found '\0' */
2183 else
2184 {
2185 point += tmp;
2186 max -= tmp;
2187 tmp = wcwidth(wc);
2188 width += (tmp >= 0) ? tmp : 1;
2189 }
2190 }
2191
2192 width += point - end;
2193
2194 return width;
2195}
2196#endif /* HANDLE_MULTIBYTE */
2298 else
2299 {
2300 point += tmp;
2301 max -= tmp;
2302 tmp = wcwidth(wc);
2303 width += (tmp >= 0) ? tmp : 1;
2304 }
2305 }
2306
2307 width += point - end;
2308
2309 return width;
2310}
2311#endif /* HANDLE_MULTIBYTE */
2197