| 1/* $FreeBSD: head/contrib/libreadline/display.c 165675 2006-12-31 09:22:31Z ache $ */ |
| 2/* display.c -- readline redisplay facility. */ 3 |
| 4/* Copyright (C) 1987-2006 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. --- 42 unchanged lines hidden (view full) --- 55 56#include "rlprivate.h" 57#include "xmalloc.h" 58 59#if !defined (strchr) && !defined (__STDC__) 60extern char *strchr (), *strrchr (); 61#endif /* !strchr && !__STDC__ */ 62 |
| 63static void update_line PARAMS((char *, char *, int, int, int, int)); 64static void space_to_eol PARAMS((int)); 65static void delete_chars PARAMS((int)); 66static void insert_some_chars PARAMS((char *, int, int)); 67static void cr PARAMS((void)); 68 69#if defined (HANDLE_MULTIBYTE) 70static int _rl_col_width PARAMS((const char *, int, int)); 71static int *_rl_wrapped_line; 72#else 73# define _rl_col_width(l, s, e) (((e) <= (s)) ? 0 : (e) - (s)) 74#endif 75 76static int *inv_lbreaks, *vis_lbreaks; 77static int inv_lbsize, vis_lbsize; 78 79/* Heuristic used to decide whether it is faster to move from CUR to NEW |
| 80 by backing up or outputting a carriage return and moving forward. CUR 81 and NEW are either both buffer positions or absolute screen positions. */ |
| 82#define CR_FASTER(new, cur) (((new) + 1) < ((cur) - (new))) 83 |
| 84/* _rl_last_c_pos is an absolute cursor position in multibyte locales and a 85 buffer index in others. This macro is used when deciding whether the 86 current cursor position is in the middle of a prompt string containing 87 invisible characters. */ 88#define PROMPT_ENDING_INDEX \ 89 ((MB_CUR_MAX > 1 && rl_byte_oriented == 0) ? prompt_physical_chars : prompt_last_invisible+1) 90 91 |
| 92/* **************************************************************** */ 93/* */ 94/* Display stuff */ 95/* */ 96/* **************************************************************** */ 97 98/* This is the stuff that is hard for me. I never seem to write good 99 display routines in C. Let's see how I do this time. */ --- 36 unchanged lines hidden (view full) --- 136/* NOTE: _rl_last_c_pos is used as a buffer index when not in a locale 137 supporting multibyte characters, and an absolute cursor position when 138 in such a locale. This is an artifact of the donated multibyte support. 139 Care must be taken when modifying its value. */ 140int _rl_last_c_pos = 0; 141int _rl_last_v_pos = 0; 142 143static int cpos_adjusted; |
| 144static int cpos_buffer_position; |
| 145 146/* Number of lines currently on screen minus 1. */ 147int _rl_vis_botlin = 0; 148 149/* Variables used only in this file. */ 150/* The last left edge of text that was displayed. This is used when 151 doing horizontal scrolling. It shifts in thirds of a screenwidth. */ 152static int last_lmargin; --- 11 unchanged lines hidden (view full) --- 164 165/* Default and initial buffer size. Can grow. */ 166static int line_size = 1024; 167 168/* Variables to keep track of the expanded prompt string, which may 169 include invisible characters. */ 170 171static char *local_prompt, *local_prompt_prefix; |
| 172static int local_prompt_len; |
| 173static int prompt_visible_length, prompt_prefix_length; 174 175/* The number of invisible characters in the line currently being 176 displayed on the screen. */ 177static int visible_wrap_offset; 178 179/* The number of invisible characters in the prompt string. Static so it 180 can be shared between rl_redisplay and update_line */ --- 19 unchanged lines hidden (view full) --- 200 201/* These are getting numerous enough that it's time to create a struct. */ 202 203static char *saved_local_prompt; 204static char *saved_local_prefix; 205static int saved_last_invisible; 206static int saved_visible_length; 207static int saved_prefix_length; |
| 208static int saved_local_length; |
| 209static int saved_invis_chars_first_line; 210static int saved_physical_chars; 211 212/* Expand the prompt string S and return the number of visible 213 characters in *LP, if LP is not null. This is currently more-or-less 214 a placeholder for expansion. LIP, if non-null is a place to store the 215 index of the last invisible character in the returned string. NIFLP, 216 if non-zero, is a place to store the number of invisible characters in --- 7 unchanged lines hidden (view full) --- 224 the returned string; all characters except those between \001 and 225 \002 are assumed to be `visible'. */ 226 227static char * 228expand_prompt (pmt, lp, lip, niflp, vlp) 229 char *pmt; 230 int *lp, *lip, *niflp, *vlp; 231{ |
| 232 char *r, *ret, *p, *igstart; |
| 233 int l, rl, last, ignoring, ninvis, invfl, invflset, ind, pind, physchars; 234 235 /* Short-circuit if we can. */ 236 if ((MB_CUR_MAX <= 1 || rl_byte_oriented) && strchr (pmt, RL_PROMPT_START_IGNORE) == 0) 237 { 238 r = savestring (pmt); 239 if (lp) 240 *lp = strlen (r); --- 7 unchanged lines hidden (view full) --- 248 } 249 250 l = strlen (pmt); 251 r = ret = (char *)xmalloc (l + 1); 252 253 invfl = 0; /* invisible chars in first line of prompt */ 254 invflset = 0; /* we only want to set invfl once */ 255 |
| 256 igstart = 0; |
| 257 for (rl = ignoring = last = ninvis = physchars = 0, p = pmt; p && *p; p++) 258 { 259 /* This code strips the invisible character string markers 260 RL_PROMPT_START_IGNORE and RL_PROMPT_END_IGNORE */ |
| 261 if (ignoring == 0 && *p == RL_PROMPT_START_IGNORE) /* XXX - check ignoring? */ |
| 262 { |
| 263 ignoring = 1; 264 igstart = p; |
| 265 continue; 266 } 267 else if (ignoring && *p == RL_PROMPT_END_IGNORE) 268 { 269 ignoring = 0; |
| 270 if (p != (igstart + 1)) |
| 271 last = r - ret - 1; 272 continue; 273 } 274 else 275 { 276#if defined (HANDLE_MULTIBYTE) 277 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0) 278 { --- 83 unchanged lines hidden (view full) --- 362 char *p, *t; 363 int c; 364 365 /* Clear out any saved values. */ 366 FREE (local_prompt); 367 FREE (local_prompt_prefix); 368 369 local_prompt = local_prompt_prefix = (char *)0; |
| 370 local_prompt_len = 0; |
| 371 prompt_last_invisible = prompt_invis_chars_first_line = 0; 372 prompt_visible_length = prompt_physical_chars = 0; 373 374 if (prompt == 0 || *prompt == 0) 375 return (0); 376 377 p = strrchr (prompt, '\n'); 378 if (!p) 379 { 380 /* The prompt is only one logical line, though it might wrap. */ 381 local_prompt = expand_prompt (prompt, &prompt_visible_length, 382 &prompt_last_invisible, 383 &prompt_invis_chars_first_line, 384 &prompt_physical_chars); 385 local_prompt_prefix = (char *)0; |
| 386 local_prompt_len = local_prompt ? strlen (local_prompt) : 0; |
| 387 return (prompt_visible_length); 388 } 389 else 390 { 391 /* The prompt spans multiple lines. */ 392 t = ++p; 393 local_prompt = expand_prompt (p, &prompt_visible_length, 394 &prompt_last_invisible, 395 (int *)NULL, 396 &prompt_physical_chars); 397 c = *t; *t = '\0'; 398 /* The portion of the prompt string up to and including the 399 final newline is now null-terminated. */ 400 local_prompt_prefix = expand_prompt (prompt, &prompt_prefix_length, 401 (int *)NULL, 402 &prompt_invis_chars_first_line, 403 (int *)NULL); 404 *t = c; |
| 405 local_prompt_len = local_prompt ? strlen (local_prompt) : 0; |
| 406 return (prompt_prefix_length); 407 } 408} 409 410/* Initialize the VISIBLE_LINE and INVISIBLE_LINE arrays, and their associated 411 arrays of line break markers. MINSIZE is the minimum size of VISIBLE_LINE 412 and INVISIBLE_LINE; if it is greater than LINE_SIZE, LINE_SIZE is 413 increased. If the lines have already been allocated, this ensures that --- 40 unchanged lines hidden (view full) --- 454} 455 456/* Basic redisplay algorithm. */ 457void 458rl_redisplay () 459{ 460 register int in, out, c, linenum, cursor_linenum; 461 register char *line; |
| 462 int inv_botlin, lb_botlin, lb_linenum, o_cpos; |
| 463 int newlines, lpos, temp, modmark, n0, num; 464 char *prompt_this_line; 465#if defined (HANDLE_MULTIBYTE) 466 wchar_t wc; 467 size_t wc_bytes; 468 int wc_width; 469 mbstate_t ps; 470 int _rl_wrapped_multicolumn = 0; --- 7 unchanged lines hidden (view full) --- 478 479 if (invisible_line == 0 || vis_lbreaks == 0) 480 { 481 init_line_structures (0); 482 rl_on_new_line (); 483 } 484 485 /* Draw the line into the buffer. */ |
| 486 cpos_buffer_position = -1; |
| 487 488 line = invisible_line; 489 out = inv_botlin = 0; 490 491 /* Mark the line as modified or not. We only do this for history 492 lines. */ 493 modmark = 0; 494 if (_rl_mark_modified_lines && current_history () && rl_undo_list) --- 10 unchanged lines hidden (view full) --- 505 rl_display_fixed = 0; 506 507 /* If the prompt to be displayed is the `primary' readline prompt (the 508 one passed to readline()), use the values we have already expanded. 509 If not, use what's already in rl_display_prompt. WRAP_OFFSET is the 510 number of non-visible characters in the prompt string. */ 511 if (rl_display_prompt == rl_prompt || local_prompt) 512 { |
| 513 if (local_prompt_prefix && forced_display) 514 _rl_output_some_chars (local_prompt_prefix, strlen (local_prompt_prefix)); 515 |
| 516 if (local_prompt_len > 0) |
| 517 { |
| 518 temp = local_prompt_len + out + 2; |
| 519 if (temp >= line_size) 520 { 521 line_size = (temp + 1024) - (temp % 1024); 522 visible_line = (char *)xrealloc (visible_line, line_size); 523 line = invisible_line = (char *)xrealloc (invisible_line, line_size); 524 } |
| 525 strncpy (line + out, local_prompt, local_prompt_len); 526 out += local_prompt_len; |
| 527 } 528 line[out] = '\0'; |
| 529 wrap_offset = local_prompt_len - prompt_visible_length; |
| 530 } 531 else 532 { 533 int pmtlen; 534 prompt_this_line = strrchr (rl_display_prompt, '\n'); 535 if (!prompt_this_line) 536 prompt_this_line = rl_display_prompt; 537 else --- 84 unchanged lines hidden (view full) --- 622 the first physical line of the prompt. 623 wrap_offset - prompt_invis_chars_first_line is the number of invis 624 chars on the second line. */ 625 626 /* what if lpos is already >= _rl_screenwidth before we start drawing the 627 contents of the command line? */ 628 while (lpos >= _rl_screenwidth) 629 { |
| 630 int z; |
| 631 /* fix from Darin Johnson <darin@acuson.com> for prompt string with 632 invisible characters that is longer than the screen width. The 633 prompt_invis_chars_first_line variable could be made into an array 634 saying how many invisible characters there are per line, but that's 635 probably too much work for the benefit gained. How many people have 636 prompts that exceed two physical lines? 637 Additional logic fix from Edward Catmur <ed@catmur.co.uk> */ 638#if defined (HANDLE_MULTIBYTE) |
| 639 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0) |
| 640 { |
| 641 n0 = num; 642 temp = local_prompt_len; 643 while (num < temp) |
| 644 { |
| 645 z = _rl_col_width (local_prompt, n0, num); 646 if (z > _rl_screenwidth) 647 { 648 num = _rl_find_prev_mbchar (local_prompt, num, MB_FIND_ANY); 649 break; 650 } 651 else if (z == _rl_screenwidth) 652 break; 653 num++; |
| 654 } |
| 655 temp = num; |
| 656 } |
| 657 else |
| 658#endif /* !HANDLE_MULTIBYTE */ |
| 659 temp = ((newlines + 1) * _rl_screenwidth); 660 661 /* Now account for invisible characters in the current line. */ 662 temp += ((local_prompt_prefix == 0) ? ((newlines == 0) ? prompt_invis_chars_first_line 663 : ((newlines == 1) ? wrap_offset : 0)) 664 : ((newlines == 0) ? wrap_offset :0)); |
| 665 666 inv_lbreaks[++newlines] = temp; 667#if defined (HANDLE_MULTIBYTE) |
| 668 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0) 669 lpos -= _rl_col_width (local_prompt, n0, num); 670 else |
| 671#endif |
| 672 lpos -= _rl_screenwidth; |
| 673 } 674 675 prompt_last_screen_line = newlines; 676 677 /* Draw the rest of the line (after the prompt) into invisible_line, keeping |
| 678 track of where the cursor is (cpos_buffer_position), the number of the line containing |
| 679 the cursor (lb_linenum), the last line number (lb_botlin and inv_botlin). 680 It maintains an array of line breaks for display (inv_lbreaks). 681 This handles expanding tabs for display and displaying meta characters. */ 682 lb_linenum = 0; 683#if defined (HANDLE_MULTIBYTE) 684 in = 0; 685 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0) 686 { --- 36 unchanged lines hidden (view full) --- 723 line_size *= 2; 724 visible_line = (char *)xrealloc (visible_line, line_size); 725 invisible_line = (char *)xrealloc (invisible_line, line_size); 726 line = invisible_line; 727 } 728 729 if (in == rl_point) 730 { |
| 731 cpos_buffer_position = out; |
| 732 lb_linenum = newlines; 733 } 734 735#if defined (HANDLE_MULTIBYTE) 736 if (META_CHAR (c) && _rl_output_meta_chars == 0) /* XXX - clean up */ 737#else 738 if (META_CHAR (c)) 739#endif --- 77 unchanged lines hidden (view full) --- 817 { 818 /* The space will be removed in update_line() */ 819 line[out++] = ' '; 820 _rl_wrapped_multicolumn++; 821 CHECK_LPOS(); 822 } 823 if (in == rl_point) 824 { |
| 825 cpos_buffer_position = out; |
| 826 lb_linenum = newlines; 827 } 828 for (i = in; i < in+wc_bytes; i++) 829 line[out++] = rl_line_buffer[i]; 830 for (i = 0; i < wc_width; i++) 831 CHECK_LPOS(); 832 } 833 else --- 14 unchanged lines hidden (view full) --- 848 wc_bytes = mbrtowc (&wc, rl_line_buffer + in, rl_end - in, &ps); 849 } 850 else 851 in++; 852#endif 853 854 } 855 line[out] = '\0'; |
| 856 if (cpos_buffer_position < 0) |
| 857 { |
| 858 cpos_buffer_position = out; |
| 859 lb_linenum = newlines; 860 } 861 862 inv_botlin = lb_botlin = newlines; 863 CHECK_INV_LBREAKS (); 864 inv_lbreaks[newlines+1] = out; 865 cursor_linenum = lb_linenum; 866 |
| 867 /* CPOS_BUFFER_POSITION == position in buffer where cursor should be placed. |
| 868 CURSOR_LINENUM == line number where the cursor should be placed. */ 869 870 /* PWP: now is when things get a bit hairy. The visible and invisible 871 line buffers are really multiple lines, which would wrap every 872 (screenwidth - 1) characters. Go through each in turn, finding 873 the changed region and updating it. The line order is top to bottom. */ 874 875 /* If we can move the cursor up and down, then use multiple lines, --- 28 unchanged lines hidden (view full) --- 904#define INV_LLEN(l) (inv_lbreaks[l+1] - inv_lbreaks[l]) 905#define VIS_CHARS(line) (visible_line + vis_lbreaks[line]) 906#define VIS_LINE(line) ((line) > _rl_vis_botlin) ? "" : VIS_CHARS(line) 907#define INV_LINE(line) (invisible_line + inv_lbreaks[line]) 908 909 /* For each line in the buffer, do the updating display. */ 910 for (linenum = 0; linenum <= inv_botlin; linenum++) 911 { |
| 912 /* This can lead us astray if we execute a program that changes 913 the locale from a non-multibyte to a multibyte one. */ |
| 914 o_cpos = _rl_last_c_pos; 915 cpos_adjusted = 0; 916 update_line (VIS_LINE(linenum), INV_LINE(linenum), linenum, 917 VIS_LLEN(linenum), INV_LLEN(linenum), inv_botlin); 918 919 /* update_line potentially changes _rl_last_c_pos, but doesn't 920 take invisible characters into account, since _rl_last_c_pos 921 is an absolute cursor position in a multibyte locale. See 922 if compensating here is the right thing, or if we have to 923 change update_line itself. There is one case in which 924 update_line adjusts _rl_last_c_pos itself (so it can pass 925 _rl_move_cursor_relative accurate values); it communicates |
| 926 this back by setting cpos_adjusted. If we assume that 927 _rl_last_c_pos is correct (an absolute cursor position) each 928 time update_line is called, then we can assume in our 929 calculations that o_cpos does not need to be adjusted by 930 wrap_offset. */ |
| 931 if (linenum == 0 && (MB_CUR_MAX > 1 && rl_byte_oriented == 0) && 932 cpos_adjusted == 0 && 933 _rl_last_c_pos != o_cpos && 934 _rl_last_c_pos > wrap_offset && 935 o_cpos < prompt_last_invisible) 936 _rl_last_c_pos -= wrap_offset; 937 938 /* If this is the line with the prompt, we might need to --- 52 unchanged lines hidden (view full) --- 991 992 /* We have to reprint the prompt if it contains invisible 993 characters, since it's not generally OK to just reprint 994 the characters from the current cursor position. But we 995 only need to reprint it if the cursor is before the last 996 invisible character in the prompt string. */ 997 nleft = prompt_visible_length + wrap_offset; 998 if (cursor_linenum == 0 && wrap_offset > 0 && _rl_last_c_pos > 0 && |
| 999#if 0 1000 _rl_last_c_pos <= PROMPT_ENDING_INDEX && local_prompt) 1001#else 1002 _rl_last_c_pos < PROMPT_ENDING_INDEX && local_prompt) 1003#endif |
| 1004 { 1005#if defined (__MSDOS__) 1006 putc ('\r', rl_outstream); 1007#else 1008 if (_rl_term_cr) 1009 tputs (_rl_term_cr, 1, _rl_output_character_function); 1010#endif 1011 _rl_output_some_chars (local_prompt, nleft); 1012 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0) 1013 _rl_last_c_pos = _rl_col_width (local_prompt, 0, nleft) - wrap_offset; 1014 else 1015 _rl_last_c_pos = nleft; 1016 } 1017 1018 /* Where on that line? And where does that line start 1019 in the buffer? */ 1020 pos = inv_lbreaks[cursor_linenum]; 1021 /* nleft == number of characters in the line buffer between the |
| 1022 start of the line and the desired cursor position. */ 1023 nleft = cpos_buffer_position - pos; |
| 1024 1025 /* NLEFT is now a number of characters in a buffer. When in a 1026 multibyte locale, however, _rl_last_c_pos is an absolute cursor 1027 position that doesn't take invisible characters in the prompt 1028 into account. We use a fudge factor to compensate. */ 1029 1030 /* Since _rl_backspace() doesn't know about invisible characters in the 1031 prompt, and there's no good way to tell it, we compensate for 1032 those characters here and call _rl_backspace() directly. */ 1033 if (wrap_offset && cursor_linenum == 0 && nleft < _rl_last_c_pos) 1034 { |
| 1035 /* TX == new physical cursor position in multibyte locale. */ |
| 1036 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0) 1037 tx = _rl_col_width (&visible_line[pos], 0, nleft) - visible_wrap_offset; 1038 else 1039 tx = nleft; 1040 if (_rl_last_c_pos > tx) 1041 { 1042 _rl_backspace (_rl_last_c_pos - tx); /* XXX */ 1043 _rl_last_c_pos = tx; --- 17 unchanged lines hidden (view full) --- 1061 1062 /* Always at top line. */ 1063 _rl_last_v_pos = 0; 1064 1065 /* Compute where in the buffer the displayed line should start. This 1066 will be LMARGIN. */ 1067 1068 /* The number of characters that will be displayed before the cursor. */ |
| 1069 ndisp = cpos_buffer_position - wrap_offset; |
| 1070 nleft = prompt_visible_length + wrap_offset; 1071 /* Where the new cursor position will be on the screen. This can be 1072 longer than SCREENWIDTH; if it is, lmargin will be adjusted. */ |
| 1073 phys_c_pos = cpos_buffer_position - (last_lmargin ? last_lmargin : wrap_offset); |
| 1074 t = _rl_screenwidth / 3; 1075 1076 /* If the number of characters had already exceeded the screenwidth, 1077 last_lmargin will be > 0. */ 1078 1079 /* If the number of characters to be displayed is more than the screen 1080 width, compute the starting offset so that the cursor is about 1081 two-thirds of the way across the screen. */ 1082 if (phys_c_pos > _rl_screenwidth - 2) 1083 { |
| 1084 lmargin = cpos_buffer_position - (2 * t); |
| 1085 if (lmargin < 0) 1086 lmargin = 0; 1087 /* If the left margin would be in the middle of a prompt with 1088 invisible characters, don't display the prompt at all. */ 1089 if (wrap_offset && lmargin > 0 && lmargin < nleft) 1090 lmargin = nleft; 1091 } 1092 else if (ndisp < _rl_screenwidth - 2) /* XXX - was -1 */ 1093 lmargin = 0; 1094 else if (phys_c_pos < 1) 1095 { 1096 /* If we are moving back towards the beginning of the line and 1097 the last margin is no longer correct, compute a new one. */ |
| 1098 lmargin = ((cpos_buffer_position - 1) / t) * t; /* XXX */ |
| 1099 if (wrap_offset && lmargin > 0 && lmargin < nleft) 1100 lmargin = nleft; 1101 } 1102 else 1103 lmargin = last_lmargin; 1104 1105 /* If the first character on the screen isn't the first character 1106 in the display line, indicate this with a special character. */ --- 28 unchanged lines hidden (view full) --- 1135 { 1136 nleft = _rl_screenwidth - t; 1137 _rl_clear_to_eol (nleft); 1138 } 1139 visible_first_line_len = out - lmargin - M_OFFSET (lmargin, wrap_offset); 1140 if (visible_first_line_len > _rl_screenwidth) 1141 visible_first_line_len = _rl_screenwidth; 1142 |
| 1143 _rl_move_cursor_relative (cpos_buffer_position - lmargin, &invisible_line[lmargin]); |
| 1144 last_lmargin = lmargin; 1145 } 1146 } 1147 fflush (rl_outstream); 1148 1149 /* Swap visible and non-visible lines. */ 1150 { 1151 char *vtemp = visible_line; --- 41 unchanged lines hidden (view full) --- 1193 int current_line, omax, nmax, inv_botlin; 1194{ 1195 register char *ofd, *ols, *oe, *nfd, *nls, *ne; 1196 int temp, lendiff, wsatend, od, nd; 1197 int current_invis_chars; 1198 int col_lendiff, col_temp; 1199#if defined (HANDLE_MULTIBYTE) 1200 mbstate_t ps_new, ps_old; |
| 1201 int new_offset, old_offset; |
| 1202#endif 1203 1204 /* If we're at the right edge of a terminal that supports xn, we're 1205 ready to wrap around, so do so. This fixes problems with knowing 1206 the exact cursor position and cut-and-paste with certain terminal 1207 emulators. In this calculation, TEMP is the physical screen 1208 position of the cursor. */ 1209 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0) --- 216 unchanged lines hidden (view full) --- 1426 string, then redraw the entire prompt string. We can only do this 1427 reliably if the terminal supports a `cr' capability. 1428 1429 This is not an efficiency hack -- there is a problem with redrawing 1430 portions of the prompt string if they contain terminal escape 1431 sequences (like drawing the `unbold' sequence without a corresponding 1432 `bold') that manifests itself on certain terminals. */ 1433 |
| 1434 lendiff = local_prompt_len; |
| 1435 od = ofd - old; /* index of first difference in visible line */ 1436 if (current_line == 0 && !_rl_horizontal_scroll_mode && 1437 _rl_term_cr && lendiff > prompt_visible_length && _rl_last_c_pos > 0 && |
| 1438 od >= lendiff && _rl_last_c_pos < PROMPT_ENDING_INDEX) |
| 1439 { 1440#if defined (__MSDOS__) 1441 putc ('\r', rl_outstream); 1442#else 1443 tputs (_rl_term_cr, 1, _rl_output_character_function); 1444#endif 1445 _rl_output_some_chars (local_prompt, lendiff); 1446 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0) 1447 { 1448 /* We take wrap_offset into account here so we can pass correct 1449 information to _rl_move_cursor_relative. */ 1450 _rl_last_c_pos = _rl_col_width (local_prompt, 0, lendiff) - wrap_offset; 1451 cpos_adjusted = 1; 1452 } 1453 else 1454 _rl_last_c_pos = lendiff; 1455 } 1456 |
| 1457 /* When this function returns, _rl_last_c_pos is correct, and an absolute 1458 cursor postion in multibyte mode, but a buffer index when not in a 1459 multibyte locale. */ |
| 1460 _rl_move_cursor_relative (od, old); |
| 1461#if 1 1462#if defined (HANDLE_MULTIBYTE) 1463 /* We need to indicate that the cursor position is correct in the presence of 1464 invisible characters in the prompt string. Let's see if setting this when 1465 we make sure we're at the end of the drawn prompt string works. */ 1466 if (current_line == 0 && MB_CUR_MAX > 1 && rl_byte_oriented == 0 && _rl_last_c_pos == prompt_physical_chars) 1467 cpos_adjusted = 1; 1468#endif 1469#endif |
| 1470 1471 /* if (len (new) > len (old)) 1472 lendiff == difference in buffer 1473 col_lendiff == difference on screen 1474 When not using multibyte characters, these are equal */ 1475 lendiff = (nls - nfd) - (ols - ofd); 1476 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0) 1477 col_lendiff = _rl_col_width (new, nfd - new, nls - new) - _rl_col_width (old, ofd - old, ols - old); --- 211 unchanged lines hidden (view full) --- 1689 1690 return 0; 1691} 1692 1693/* Actually update the display, period. */ 1694int 1695rl_forced_update_display () 1696{ |
| 1697 register char *temp; 1698 |
| 1699 if (visible_line) 1700 { |
| 1701 temp = visible_line; |
| 1702 while (*temp) 1703 *temp++ = '\0'; 1704 } 1705 rl_on_new_line (); 1706 forced_display++; 1707 (*rl_redisplay_function) (); 1708 return 0; 1709} --- 18 unchanged lines hidden (view full) --- 1728 /* If we have multibyte characters, NEW is indexed by the buffer point in 1729 a multibyte string, but _rl_last_c_pos is the display position. In 1730 this case, NEW's display position is not obvious and must be 1731 calculated. We need to account for invisible characters in this line, 1732 as long as we are past them and they are counted by _rl_col_width. */ 1733 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0) 1734 { 1735 dpos = _rl_col_width (data, 0, new); |
| 1736 if (dpos > prompt_last_invisible) /* XXX - don't use woff here */ 1737 { 1738 dpos -= woff; 1739 /* Since this will be assigned to _rl_last_c_pos at the end (more 1740 precisely, _rl_last_c_pos == dpos when this function returns), 1741 let the caller know. */ 1742 cpos_adjusted = 1; 1743 } |
| 1744 } 1745 else 1746#endif 1747 dpos = new; 1748 1749 /* If we don't have to do anything, then return. */ 1750 if (cpos == dpos) 1751 return; 1752 1753 /* It may be faster to output a CR, and then move forwards instead 1754 of moving backwards. */ 1755 /* i == current physical cursor position. */ 1756#if defined (HANDLE_MULTIBYTE) 1757 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0) 1758 i = _rl_last_c_pos; 1759 else 1760#endif 1761 i = _rl_last_c_pos - woff; |
| 1762 if (dpos == 0 || CR_FASTER (dpos, _rl_last_c_pos) || |
| 1763 (_rl_term_autowrap && i == _rl_screenwidth)) 1764 { 1765#if defined (__MSDOS__) 1766 putc ('\r', rl_outstream); 1767#else 1768 tputs (_rl_term_cr, 1, _rl_output_character_function); 1769#endif /* !__MSDOS__ */ 1770 cpos = _rl_last_c_pos = 0; --- 5 unchanged lines hidden (view full) --- 1776 to move the cursor forward if there is one, else print that 1777 portion of the output buffer again. Which is cheaper? */ 1778 1779 /* The above comment is left here for posterity. It is faster 1780 to print one character (non-control) than to print a control 1781 sequence telling the terminal to move forward one character. 1782 That kind of control is for people who don't know what the 1783 data is underneath the cursor. */ |
| 1784 1785 /* However, we need a handle on where the current display position is 1786 in the buffer for the immediately preceding comment to be true. 1787 In multibyte locales, we don't currently have that info available. 1788 Without it, we don't know where the data we have to display begins 1789 in the buffer and we have to go back to the beginning of the screen 1790 line. In this case, we can use the terminal sequence to move forward 1791 if it's available. */ |
| 1792 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0) 1793 { |
| 1794 if (_rl_term_forward_char) 1795 { 1796 for (i = cpos; i < dpos; i++) 1797 tputs (_rl_term_forward_char, 1, _rl_output_character_function); 1798 } 1799 else 1800 { 1801 tputs (_rl_term_cr, 1, _rl_output_character_function); 1802 for (i = 0; i < new; i++) 1803 putc (data[i], rl_outstream); 1804 } |
| 1805 } 1806 else 1807 for (i = cpos; i < new; i++) 1808 putc (data[i], rl_outstream); 1809 } 1810 1811#if defined (HANDLE_MULTIBYTE) 1812 /* NEW points to the buffer point, but _rl_last_c_pos is the display point. --- 132 unchanged lines hidden (view full) --- 1945 msg_saved_prompt = 1; 1946 } 1947 rl_display_prompt = msg_buf; 1948 local_prompt = expand_prompt (msg_buf, &prompt_visible_length, 1949 &prompt_last_invisible, 1950 &prompt_invis_chars_first_line, 1951 &prompt_physical_chars); 1952 local_prompt_prefix = (char *)NULL; |
| 1953 local_prompt_len = local_prompt ? strlen (local_prompt) : 0; |
| 1954 (*rl_redisplay_function) (); 1955 1956 return 0; 1957} 1958#else /* !USE_VARARGS */ 1959int 1960rl_message (format, arg1, arg2) 1961 char *format; --- 7 unchanged lines hidden (view full) --- 1969 rl_save_prompt (); 1970 msg_saved_prompt = 1; 1971 } 1972 local_prompt = expand_prompt (msg_buf, &prompt_visible_length, 1973 &prompt_last_invisible, 1974 &prompt_invis_chars_first_line, 1975 &prompt_physical_chars); 1976 local_prompt_prefix = (char *)NULL; |
| 1977 local_prompt_len = local_prompt ? strlen (local_prompt) : 0; |
| 1978 (*rl_redisplay_function) (); 1979 1980 return 0; 1981} 1982#endif /* !USE_VARARGS */ 1983 1984/* How to clear things from the "echo-area". */ 1985int --- 20 unchanged lines hidden (view full) --- 2006} 2007 2008void 2009rl_save_prompt () 2010{ 2011 saved_local_prompt = local_prompt; 2012 saved_local_prefix = local_prompt_prefix; 2013 saved_prefix_length = prompt_prefix_length; |
| 2014 saved_local_length = local_prompt_len; |
| 2015 saved_last_invisible = prompt_last_invisible; 2016 saved_visible_length = prompt_visible_length; 2017 saved_invis_chars_first_line = prompt_invis_chars_first_line; 2018 saved_physical_chars = prompt_physical_chars; 2019 2020 local_prompt = local_prompt_prefix = (char *)0; |
| 2021 local_prompt_len = 0; |
| 2022 prompt_last_invisible = prompt_visible_length = prompt_prefix_length = 0; 2023 prompt_invis_chars_first_line = prompt_physical_chars = 0; 2024} 2025 2026void 2027rl_restore_prompt () 2028{ 2029 FREE (local_prompt); 2030 FREE (local_prompt_prefix); 2031 2032 local_prompt = saved_local_prompt; 2033 local_prompt_prefix = saved_local_prefix; |
| 2034 local_prompt_len = saved_local_length; |
| 2035 prompt_prefix_length = saved_prefix_length; 2036 prompt_last_invisible = saved_last_invisible; 2037 prompt_visible_length = saved_visible_length; 2038 prompt_invis_chars_first_line = saved_invis_chars_first_line; 2039 prompt_physical_chars = saved_physical_chars; 2040 2041 /* can test saved_local_prompt to see if prompt info has been saved. */ 2042 saved_local_prompt = saved_local_prefix = (char *)0; |
| 2043 saved_local_length = 0; |
| 2044 saved_last_invisible = saved_visible_length = saved_prefix_length = 0; 2045 saved_invis_chars_first_line = saved_physical_chars = 0; 2046} 2047 2048char * 2049_rl_make_prompt_for_search (pchar) 2050 int pchar; 2051{ --- 172 unchanged lines hidden (view full) --- 2224 } 2225 _rl_move_vert (_rl_vis_botlin); 2226 /* If we've wrapped lines, remove the final xterm line-wrap flag. */ 2227 if (full_lines && _rl_term_autowrap && (VIS_LLEN(_rl_vis_botlin) == _rl_screenwidth)) 2228 { 2229 char *last_line; 2230 2231 last_line = &visible_line[vis_lbreaks[_rl_vis_botlin]]; |
| 2232 cpos_buffer_position = -1; /* don't know where we are in buffer */ 2233 _rl_move_cursor_relative (_rl_screenwidth - 1, last_line); /* XXX */ |
| 2234 _rl_clear_to_eol (0); 2235 putc (last_line[_rl_screenwidth - 1], rl_outstream); 2236 } 2237 _rl_vis_botlin = 0; 2238 rl_crlf (); 2239 fflush (rl_outstream); 2240 rl_display_fixed++; 2241} --- 26 unchanged lines hidden (view full) --- 2268 rl_save_prompt (); 2269 2270 rl_display_prompt = t; 2271 local_prompt = expand_prompt (t, &prompt_visible_length, 2272 &prompt_last_invisible, 2273 &prompt_invis_chars_first_line, 2274 &prompt_physical_chars); 2275 local_prompt_prefix = (char *)NULL; |
| 2276 local_prompt_len = local_prompt ? strlen (local_prompt) : 0; |
| 2277 2278 rl_forced_update_display (); 2279 2280 rl_display_prompt = oldp; 2281 rl_restore_prompt(); 2282} 2283 2284/* Redisplay the current line after a SIGWINCH is received. */ --- 86 unchanged lines hidden (view full) --- 2371 In the case of multibyte characters with stateful encoding, we have to 2372 scan from the beginning of the string to take the state into account. */ 2373static int 2374_rl_col_width (str, start, end) 2375 const char *str; 2376 int start, end; 2377{ 2378 wchar_t wc; |
| 2379 mbstate_t ps; |
| 2380 int tmp, point, width, max; 2381 2382 if (end <= start) 2383 return 0; 2384 |
| 2385 memset (&ps, 0, sizeof (mbstate_t)); 2386 |
| 2387 point = 0; 2388 max = end; 2389 2390 while (point < start) 2391 { 2392 tmp = mbrlen (str + point, max, &ps); 2393 if (MB_INVALIDCH ((size_t)tmp)) 2394 { --- 58 unchanged lines hidden --- |