1: /* display.c -- readline redisplay facility. */
2:
3: /* Copyright (C) 1987-2013 Free Software Foundation, Inc.
4:
5: This file is part of the GNU Readline Library (Readline), a library
6: for reading lines of text with interactive input and history editing.
7:
8: Readline is free software: you can redistribute it and/or modify
9: it under the terms of the GNU General Public License as published by
10: the Free Software Foundation, either version 3 of the License, or
11: (at your option) any later version.
12:
13: Readline is distributed in the hope that it will be useful,
14: but WITHOUT ANY WARRANTY; without even the implied warranty of
15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16: GNU General Public License for more details.
17:
18: You should have received a copy of the GNU General Public License
19: along with Readline. If not, see <http://www.gnu.org/licenses/>.
20: */
21:
22: #define READLINE_LIBRARY
23:
24: #if defined (HAVE_CONFIG_H)
25: # include <config.h>
26: #endif
27:
28: #include <sys/types.h>
29:
30: #if defined (HAVE_UNISTD_H)
31: # include <unistd.h>
32: #endif /* HAVE_UNISTD_H */
33:
34: #include "posixstat.h"
35:
36: #if defined (HAVE_STDLIB_H)
37: # include <stdlib.h>
38: #else
39: # include "ansi_stdlib.h"
40: #endif /* HAVE_STDLIB_H */
41:
42: #include <stdio.h>
43:
44: #ifdef __MSDOS__
45: # include <pc.h>
46: #endif
47:
48: /* System-specific feature definitions and include files. */
49: #include "rldefs.h"
50: #include "rlmbutil.h"
51:
52: /* Termcap library stuff. */
53: #include "tcap.h"
54:
55: /* Some standard library routines. */
56: #include "readline.h"
57: #include "history.h"
58:
59: #include "rlprivate.h"
60: #include "xmalloc.h"
61:
62: #if !defined (strchr) && !defined (__STDC__)
63: extern char *strchr (), *strrchr ();
64: #endif /* !strchr && !__STDC__ */
65:
66: static void update_line PARAMS((char *, char *, int, int, int, int));
67: static void space_to_eol PARAMS((int));
68: static void delete_chars PARAMS((int));
69: static void insert_some_chars PARAMS((char *, int, int));
70: static void open_some_spaces PARAMS((int));
71: static void cr PARAMS((void));
72:
73: /* State of visible and invisible lines. */
74: struct line_state
75: {
76: char *line;
77: int *lbreaks;
78: int lbsize;
79: #if defined (HANDLE_MULTIBYTE)
80: int *wrapped_line;
81: int wbsize;
82: #endif
83: };
84:
85: /* The line display buffers. One is the line currently displayed on
86: the screen. The other is the line about to be displayed. */
87: static struct line_state line_state_array[2];
88: static struct line_state *line_state_visible = &line_state_array[0];
89: static struct line_state *line_state_invisible = &line_state_array[1];
90: static int line_structures_initialized = 0;
91:
92: /* Backwards-compatible names. */
93: #define inv_lbreaks (line_state_invisible->lbreaks)
94: #define inv_lbsize (line_state_invisible->lbsize)
95: #define vis_lbreaks (line_state_visible->lbreaks)
96: #define vis_lbsize (line_state_visible->lbsize)
97:
98: #define visible_line (line_state_visible->line)
99: #define invisible_line (line_state_invisible->line)
100:
101: #if defined (HANDLE_MULTIBYTE)
102: static int _rl_col_width PARAMS((const char *, int, int, int));
103: #else
104: # define _rl_col_width(l, s, e, f) (((e) <= (s)) ? 0 : (e) - (s))
105: #endif
106:
107: /* Heuristic used to decide whether it is faster to move from CUR to NEW
108: by backing up or outputting a carriage return and moving forward. CUR
109: and NEW are either both buffer positions or absolute screen positions. */
110: #define CR_FASTER(new, cur) (((new) + 1) < ((cur) - (new)))
111:
112: /* _rl_last_c_pos is an absolute cursor position in multibyte locales and a
113: buffer index in others. This macro is used when deciding whether the
114: current cursor position is in the middle of a prompt string containing
115: invisible characters. XXX - might need to take `modmark' into account. */
116: #define PROMPT_ENDING_INDEX \
117: ((MB_CUR_MAX > 1 && rl_byte_oriented == 0) ? prompt_physical_chars : prompt_last_invisible+1)
118:
119:
120: /* **************************************************************** */
121: /* */
122: /* Display stuff */
123: /* */
124: /* **************************************************************** */
125:
126: /* This is the stuff that is hard for me. I never seem to write good
127: display routines in C. Let's see how I do this time. */
128:
129: /* (PWP) Well... Good for a simple line updater, but totally ignores
130: the problems of input lines longer than the screen width.
131:
132: update_line and the code that calls it makes a multiple line,
133: automatically wrapping line update. Careful attention needs
134: to be paid to the vertical position variables. */
135:
136: /* Keep two buffers; one which reflects the current contents of the
137: screen, and the other to draw what we think the new contents should
138: be. Then compare the buffers, and make whatever changes to the
139: screen itself that we should. Finally, make the buffer that we
140: just drew into be the one which reflects the current contents of the
141: screen, and place the cursor where it belongs.
142:
143: Commands that want to can fix the display themselves, and then let
144: this function know that the display has been fixed by setting the
145: RL_DISPLAY_FIXED variable. This is good for efficiency. */
146:
147: /* Application-specific redisplay function. */
148: rl_voidfunc_t *rl_redisplay_function = rl_redisplay;
149:
150: /* Global variables declared here. */
151: /* What YOU turn on when you have handled all redisplay yourself. */
152: int rl_display_fixed = 0;
153:
154: int _rl_suppress_redisplay = 0;
155: int _rl_want_redisplay = 0;
156:
157: /* The stuff that gets printed out before the actual text of the line.
158: This is usually pointing to rl_prompt. */
159: char *rl_display_prompt = (char *)NULL;
160:
161: /* Pseudo-global variables declared here. */
162:
163: /* The visible cursor position. If you print some text, adjust this. */
164: /* NOTE: _rl_last_c_pos is used as a buffer index when not in a locale
165: supporting multibyte characters, and an absolute cursor position when
166: in such a locale. This is an artifact of the donated multibyte support.
167: Care must be taken when modifying its value. */
168: int _rl_last_c_pos = 0;
169: int _rl_last_v_pos = 0;
170:
171: static int cpos_adjusted;
172: static int cpos_buffer_position;
173: static int displaying_prompt_first_line;
174: static int prompt_multibyte_chars;
175:
176: /* Number of lines currently on screen minus 1. */
177: int _rl_vis_botlin = 0;
178:
179: /* Variables used only in this file. */
180: /* The last left edge of text that was displayed. This is used when
181: doing horizontal scrolling. It shifts in thirds of a screenwidth. */
182: static int last_lmargin;
183:
184: /* A buffer for `modeline' messages. */
185: static char *msg_buf = 0;
186: static int msg_bufsiz = 0;
187:
188: /* Non-zero forces the redisplay even if we thought it was unnecessary. */
189: static int forced_display;
190:
191: /* Default and initial buffer size. Can grow. */
192: static int line_size = 1024;
193:
194: /* Variables to keep track of the expanded prompt string, which may
195: include invisible characters. */
196:
197: static char *local_prompt, *local_prompt_prefix;
198: static int local_prompt_len;
199: static int prompt_visible_length, prompt_prefix_length;
200:
201: /* The number of invisible characters in the line currently being
202: displayed on the screen. */
203: static int visible_wrap_offset;
204:
205: /* The number of invisible characters in the prompt string. Static so it
206: can be shared between rl_redisplay and update_line */
207: static int wrap_offset;
208:
209: /* The index of the last invisible character in the prompt string. */
210: static int prompt_last_invisible;
211:
212: /* The length (buffer offset) of the first line of the last (possibly
213: multi-line) buffer displayed on the screen. */
214: static int visible_first_line_len;
215:
216: /* Number of invisible characters on the first physical line of the prompt.
217: Only valid when the number of physical characters in the prompt exceeds
218: (or is equal to) _rl_screenwidth. */
219: static int prompt_invis_chars_first_line;
220:
221: static int prompt_last_screen_line;
222:
223: static int prompt_physical_chars;
224:
225: /* set to a non-zero value by rl_redisplay if we are marking modified history
226: lines and the current line is so marked. */
227: static int modmark;
228:
229: /* Variables to save and restore prompt and display information. */
230:
231: /* These are getting numerous enough that it's time to create a struct. */
232:
233: static char *saved_local_prompt;
234: static char *saved_local_prefix;
235: static int saved_last_invisible;
236: static int saved_visible_length;
237: static int saved_prefix_length;
238: static int saved_local_length;
239: static int saved_invis_chars_first_line;
240: static int saved_physical_chars;
241:
242: /* Return a character indicating the editing mode, for use in the prompt. */
243: static int
244: prompt_modechar ()
245: {
246: if (rl_editing_mode == emacs_mode)
247: return '@';
248: else if (_rl_keymap == vi_insertion_keymap)
249: return '+'; /* vi insert mode */
250: else
251: return ':'; /* vi command mode */
252: }
253:
254: /* Expand the prompt string S and return the number of visible
255: characters in *LP, if LP is not null. This is currently more-or-less
256: a placeholder for expansion. LIP, if non-null is a place to store the
257: index of the last invisible character in the returned string. NIFLP,
258: if non-zero, is a place to store the number of invisible characters in
259: the first prompt line. The previous are used as byte counts -- indexes
260: into a character buffer. */
261:
262: /* Current implementation:
263: \001 (^A) start non-visible characters
264: \002 (^B) end non-visible characters
265: all characters except \001 and \002 (following a \001) are copied to
266: the returned string; all characters except those between \001 and
267: \002 are assumed to be `visible'. */
268:
269: static char *
270: expand_prompt (pmt, lp, lip, niflp, vlp)
271: char *pmt;
272: int *lp, *lip, *niflp, *vlp;
273: {
274: char *r, *ret, *p, *igstart;
275: int l, rl, last, ignoring, ninvis, invfl, invflset, ind, pind, physchars;
276:
277: /* Short-circuit if we can. */
278: if ((MB_CUR_MAX <= 1 || rl_byte_oriented) && strchr (pmt, RL_PROMPT_START_IGNORE) == 0)
279: {
280: if (pmt == rl_prompt && _rl_show_mode_in_prompt)
281: {
282: l = strlen (pmt);
283: r = (char *)xmalloc (l + 2);
284: r[0] = prompt_modechar ();
285: strcpy (r + 1, pmt);
286: }
287: else
288: r = savestring (pmt);
289:
290: if (lp)
291: *lp = strlen (r);
292: if (lip)
293: *lip = 0;
294: if (niflp)
295: *niflp = 0;
296: if (vlp)
297: *vlp = lp ? *lp : strlen (r);
298: return r;
299: }
300:
301: l = strlen (pmt);
302: r = ret = (char *)xmalloc (l + 2);
303:
304: rl = physchars = 0; /* move up here so mode show can set them */
305: if (pmt == rl_prompt && _rl_show_mode_in_prompt)
306: {
307: *r++ = prompt_modechar ();
308: rl = physchars = 1;
309: }
310:
311: invfl = 0; /* invisible chars in first line of prompt */
312: invflset = 0; /* we only want to set invfl once */
313:
314: igstart = 0;
315: for (ignoring = last = ninvis = 0, p = pmt; p && *p; p++)
316: {
317: /* This code strips the invisible character string markers
318: RL_PROMPT_START_IGNORE and RL_PROMPT_END_IGNORE */
319: if (ignoring == 0 && *p == RL_PROMPT_START_IGNORE) /* XXX - check ignoring? */
320: {
321: ignoring = 1;
322: igstart = p;
323: continue;
324: }
325: else if (ignoring && *p == RL_PROMPT_END_IGNORE)
326: {
327: ignoring = 0;
328: if (p != (igstart + 1))
329: last = r - ret - 1;
330: continue;
331: }
332: else
333: {
334: #if defined (HANDLE_MULTIBYTE)
335: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
336: {
337: pind = p - pmt;
338: ind = _rl_find_next_mbchar (pmt, pind, 1, MB_FIND_NONZERO);
339: l = ind - pind;
340: while (l--)
341: *r++ = *p++;
342: if (!ignoring)
343: {
344: /* rl ends up being assigned to prompt_visible_length,
345: which is the number of characters in the buffer that
346: contribute to characters on the screen, which might
347: not be the same as the number of physical characters
348: on the screen in the presence of multibyte characters */
349: rl += ind - pind;
350: physchars += _rl_col_width (pmt, pind, ind, 0);
351: }
352: else
353: ninvis += ind - pind;
354: p--; /* compensate for later increment */
355: }
356: else
357: #endif
358: {
359: *r++ = *p;
360: if (!ignoring)
361: {
362: rl++; /* visible length byte counter */
363: physchars++;
364: }
365: else
366: ninvis++; /* invisible chars byte counter */
367: }
368:
369: if (invflset == 0 && rl >= _rl_screenwidth)
370: {
371: invfl = ninvis;
372: invflset = 1;
373: }
374: }
375: }
376:
377: if (rl < _rl_screenwidth)
378: invfl = ninvis;
379:
380: *r = '\0';
381: if (lp)
382: *lp = rl;
383: if (lip)
384: *lip = last;
385: if (niflp)
386: *niflp = invfl;
387: if (vlp)
388: *vlp = physchars;
389: return ret;
390: }
391:
392: /* Just strip out RL_PROMPT_START_IGNORE and RL_PROMPT_END_IGNORE from
393: PMT and return the rest of PMT. */
394: char *
395: _rl_strip_prompt (pmt)
396: char *pmt;
397: {
398: char *ret;
399:
400: ret = expand_prompt (pmt, (int *)NULL, (int *)NULL, (int *)NULL, (int *)NULL);
401: return ret;
402: }
403:
404: void
405: _rl_reset_prompt ()
406: {
407: rl_visible_prompt_length = rl_expand_prompt (rl_prompt);
408: }
409:
410: /*
411: * Expand the prompt string into the various display components, if
412: * necessary.
413: *
414: * local_prompt = expanded last line of string in rl_display_prompt
415: * (portion after the final newline)
416: * local_prompt_prefix = portion before last newline of rl_display_prompt,
417: * expanded via expand_prompt
418: * prompt_visible_length = number of visible characters in local_prompt
419: * prompt_prefix_length = number of visible characters in local_prompt_prefix
420: *
421: * This function is called once per call to readline(). It may also be
422: * called arbitrarily to expand the primary prompt.
423: *
424: * The return value is the number of visible characters on the last line
425: * of the (possibly multi-line) prompt.
426: */
427: int
428: rl_expand_prompt (prompt)
429: char *prompt;
430: {
431: char *p, *t;
432: int c;
433:
434: /* Clear out any saved values. */
435: FREE (local_prompt);
436: FREE (local_prompt_prefix);
437:
438: local_prompt = local_prompt_prefix = (char *)0;
439: local_prompt_len = 0;
440: prompt_last_invisible = prompt_invis_chars_first_line = 0;
441: prompt_visible_length = prompt_physical_chars = 0;
442:
443: if (prompt == 0 || *prompt == 0)
444: return (0);
445:
446: p = strrchr (prompt, '\n');
447: if (!p)
448: {
449: /* The prompt is only one logical line, though it might wrap. */
450: local_prompt = expand_prompt (prompt, &prompt_visible_length,
451: &prompt_last_invisible,
452: &prompt_invis_chars_first_line,
453: &prompt_physical_chars);
454: local_prompt_prefix = (char *)0;
455: local_prompt_len = local_prompt ? strlen (local_prompt) : 0;
456: return (prompt_visible_length);
457: }
458: else
459: {
460: /* The prompt spans multiple lines. */
461: t = ++p;
462: local_prompt = expand_prompt (p, &prompt_visible_length,
463: &prompt_last_invisible,
464: &prompt_invis_chars_first_line,
465: &prompt_physical_chars);
466: c = *t; *t = '\0';
467: /* The portion of the prompt string up to and including the
468: final newline is now null-terminated. */
469: local_prompt_prefix = expand_prompt (prompt, &prompt_prefix_length,
470: (int *)NULL,
471: (int *)NULL,
472: (int *)NULL);
473: *t = c;
474: local_prompt_len = local_prompt ? strlen (local_prompt) : 0;
475: return (prompt_prefix_length);
476: }
477: }
478:
479: /* Initialize the VISIBLE_LINE and INVISIBLE_LINE arrays, and their associated
480: arrays of line break markers. MINSIZE is the minimum size of VISIBLE_LINE
481: and INVISIBLE_LINE; if it is greater than LINE_SIZE, LINE_SIZE is
482: increased. If the lines have already been allocated, this ensures that
483: they can hold at least MINSIZE characters. */
484: static void
485: init_line_structures (minsize)
486: int minsize;
487: {
488: register int n;
489:
490: if (invisible_line == 0) /* initialize it */
491: {
492: if (line_size < minsize)
493: line_size = minsize;
494: visible_line = (char *)xmalloc (line_size);
495: invisible_line = (char *)xmalloc (line_size);
496: }
497: else if (line_size < minsize) /* ensure it can hold MINSIZE chars */
498: {
499: line_size *= 2;
500: if (line_size < minsize)
501: line_size = minsize;
502: visible_line = (char *)xrealloc (visible_line, line_size);
503: invisible_line = (char *)xrealloc (invisible_line, line_size);
504: }
505:
506: for (n = minsize; n < line_size; n++)
507: {
508: visible_line[n] = 0;
509: invisible_line[n] = 1;
510: }
511:
512: if (vis_lbreaks == 0)
513: {
514: /* should be enough. */
515: inv_lbsize = vis_lbsize = 256;
516:
517: #if defined (HANDLE_MULTIBYTE)
518: line_state_visible->wbsize = vis_lbsize;
519: line_state_visible->wrapped_line = (int *)xmalloc (line_state_visible->wbsize * sizeof (int));
520:
521: line_state_invisible->wbsize = inv_lbsize;
522: line_state_invisible->wrapped_line = (int *)xmalloc (line_state_invisible->wbsize * sizeof (int));
523: #endif
524:
525: inv_lbreaks = (int *)xmalloc (inv_lbsize * sizeof (int));
526: vis_lbreaks = (int *)xmalloc (vis_lbsize * sizeof (int));
527: inv_lbreaks[0] = vis_lbreaks[0] = 0;
528: }
529:
530: line_structures_initialized = 1;
531: }
532:
533: /* Basic redisplay algorithm. */
534: void
535: rl_redisplay ()
536: {
537: register int in, out, c, linenum, cursor_linenum;
538: register char *line;
539: int inv_botlin, lb_botlin, lb_linenum, o_cpos;
540: int newlines, lpos, temp, n0, num, prompt_lines_estimate;
541: char *prompt_this_line;
542: #if defined (HANDLE_MULTIBYTE)
543: wchar_t wc;
544: size_t wc_bytes;
545: int wc_width;
546: mbstate_t ps;
547: int _rl_wrapped_multicolumn = 0;
548: #endif
549:
550: if (_rl_echoing_p == 0)
551: return;
552:
553: /* Block keyboard interrupts because this function manipulates global
554: data structures. */
555: _rl_block_sigint ();
556: RL_SETSTATE (RL_STATE_REDISPLAYING);
557:
558: if (!rl_display_prompt)
559: rl_display_prompt = "";
560:
561: if (line_structures_initialized == 0)
562: {
563: init_line_structures (0);
564: rl_on_new_line ();
565: }
566:
567: /* Draw the line into the buffer. */
568: cpos_buffer_position = -1;
569:
570: prompt_multibyte_chars = prompt_visible_length - prompt_physical_chars;
571:
572: line = invisible_line;
573: out = inv_botlin = 0;
574:
575: /* Mark the line as modified or not. We only do this for history
576: lines. */
577: modmark = 0;
578: if (_rl_mark_modified_lines && current_history () && rl_undo_list)
579: {
580: line[out++] = '*';
581: line[out] = '\0';
582: modmark = 1;
583: }
584:
585: /* If someone thought that the redisplay was handled, but the currently
586: visible line has a different modification state than the one about
587: to become visible, then correct the caller's misconception. */
588: if (visible_line[0] != invisible_line[0])
589: rl_display_fixed = 0;
590:
591: /* If the prompt to be displayed is the `primary' readline prompt (the
592: one passed to readline()), use the values we have already expanded.
593: If not, use what's already in rl_display_prompt. WRAP_OFFSET is the
594: number of non-visible characters in the prompt string. */
595: if (rl_display_prompt == rl_prompt || local_prompt)
596: {
597: if (local_prompt_prefix && forced_display)
598: _rl_output_some_chars (local_prompt_prefix, strlen (local_prompt_prefix));
599:
600: if (local_prompt_len > 0)
601: {
602: temp = local_prompt_len + out + 2;
603: if (temp >= line_size)
604: {
605: line_size = (temp + 1024) - (temp % 1024);
606: visible_line = (char *)xrealloc (visible_line, line_size);
607: line = invisible_line = (char *)xrealloc (invisible_line, line_size);
608: }
609: strncpy (line + out, local_prompt, local_prompt_len);
610: out += local_prompt_len;
611: }
612: line[out] = '\0';
613: wrap_offset = local_prompt_len - prompt_visible_length;
614: }
615: else
616: {
617: int pmtlen;
618: prompt_this_line = strrchr (rl_display_prompt, '\n');
619: if (!prompt_this_line)
620: prompt_this_line = rl_display_prompt;
621: else
622: {
623: prompt_this_line++;
624: pmtlen = prompt_this_line - rl_display_prompt; /* temp var */
625: if (forced_display)
626: {
627: _rl_output_some_chars (rl_display_prompt, pmtlen);
628: /* Make sure we are at column zero even after a newline,
629: regardless of the state of terminal output processing. */
630: if (pmtlen < 2 || prompt_this_line[-2] != '\r')
631: cr ();
632: }
633: }
634:
635: prompt_physical_chars = pmtlen = strlen (prompt_this_line);
636: temp = pmtlen + out + 2;
637: if (temp >= line_size)
638: {
639: line_size = (temp + 1024) - (temp % 1024);
640: visible_line = (char *)xrealloc (visible_line, line_size);
641: line = invisible_line = (char *)xrealloc (invisible_line, line_size);
642: }
643: strncpy (line + out, prompt_this_line, pmtlen);
644: out += pmtlen;
645: line[out] = '\0';
646: wrap_offset = prompt_invis_chars_first_line = 0;
647: }
648:
649: #define CHECK_INV_LBREAKS() \
650: do { \
651: if (newlines >= (inv_lbsize - 2)) \
652: { \
653: inv_lbsize *= 2; \
654: inv_lbreaks = (int *)xrealloc (inv_lbreaks, inv_lbsize * sizeof (int)); \
655: } \
656: } while (0)
657:
658: #if defined (HANDLE_MULTIBYTE)
659: #define CHECK_LPOS() \
660: do { \
661: lpos++; \
662: if (lpos >= _rl_screenwidth) \
663: { \
664: if (newlines >= (inv_lbsize - 2)) \
665: { \
666: inv_lbsize *= 2; \
667: inv_lbreaks = (int *)xrealloc (inv_lbreaks, inv_lbsize * sizeof (int)); \
668: } \
669: inv_lbreaks[++newlines] = out; \
670: if (newlines >= (line_state_invisible->wbsize - 1)) \
671: { \
672: line_state_invisible->wbsize *= 2; \
673: line_state_invisible->wrapped_line = (int *)xrealloc (line_state_invisible->wrapped_line, line_state_invisible->wbsize * sizeof(int)); \
674: } \
675: line_state_invisible->wrapped_line[newlines] = _rl_wrapped_multicolumn; \
676: lpos = 0; \
677: } \
678: } while (0)
679: #else
680: #define CHECK_LPOS() \
681: do { \
682: lpos++; \
683: if (lpos >= _rl_screenwidth) \
684: { \
685: if (newlines >= (inv_lbsize - 2)) \
686: { \
687: inv_lbsize *= 2; \
688: inv_lbreaks = (int *)xrealloc (inv_lbreaks, inv_lbsize * sizeof (int)); \
689: } \
690: inv_lbreaks[++newlines] = out; \
691: lpos = 0; \
692: } \
693: } while (0)
694: #endif
695:
696: /* inv_lbreaks[i] is where line i starts in the buffer. */
697: inv_lbreaks[newlines = 0] = 0;
698: lpos = prompt_physical_chars + modmark;
699:
700: #if defined (HANDLE_MULTIBYTE)
701: memset (line_state_invisible->wrapped_line, 0, line_state_invisible->wbsize * sizeof (int));
702: num = 0;
703: #endif
704:
705: /* prompt_invis_chars_first_line is the number of invisible characters in
706: the first physical line of the prompt.
707: wrap_offset - prompt_invis_chars_first_line is the number of invis
708: chars on the second (or, more generally, last) line. */
709:
710: /* This is zero-based, used to set the newlines */
711: prompt_lines_estimate = lpos / _rl_screenwidth;
712:
713: /* what if lpos is already >= _rl_screenwidth before we start drawing the
714: contents of the command line? */
715: while (lpos >= _rl_screenwidth)
716: {
717: int z;
718: /* fix from Darin Johnson <darin@acuson.com> for prompt string with
719: invisible characters that is longer than the screen width. The
720: prompt_invis_chars_first_line variable could be made into an array
721: saying how many invisible characters there are per line, but that's
722: probably too much work for the benefit gained. How many people have
723: prompts that exceed two physical lines?
724: Additional logic fix from Edward Catmur <ed@catmur.co.uk> */
725: #if defined (HANDLE_MULTIBYTE)
726: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0 && prompt_multibyte_chars > 0)
727: {
728: n0 = num;
729: temp = local_prompt_len;
730: while (num < temp)
731: {
732: z = _rl_col_width (local_prompt, n0, num, 1);
733: if (z > _rl_screenwidth)
734: {
735: num = _rl_find_prev_mbchar (local_prompt, num, MB_FIND_ANY);
736: break;
737: }
738: else if (z == _rl_screenwidth)
739: break;
740: num++;
741: }
742: temp = num;
743: }
744: else
745: #endif /* !HANDLE_MULTIBYTE */
746: temp = ((newlines + 1) * _rl_screenwidth);
747:
748: /* Now account for invisible characters in the current line. */
749: /* XXX - this assumes that the invisible characters may be split, but only
750: between the first and the last lines. */
751: temp += (newlines == 0) ? prompt_invis_chars_first_line
752: : ((newlines == prompt_lines_estimate) ? wrap_offset : prompt_invis_chars_first_line);
753:
754: inv_lbreaks[++newlines] = temp;
755: #if defined (HANDLE_MULTIBYTE)
756: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0 && prompt_multibyte_chars > 0)
757: lpos -= _rl_col_width (local_prompt, n0, num, 1);
758: else
759: #endif
760: lpos -= _rl_screenwidth;
761: }
762:
763: prompt_last_screen_line = newlines;
764:
765: /* Draw the rest of the line (after the prompt) into invisible_line, keeping
766: track of where the cursor is (cpos_buffer_position), the number of the line containing
767: the cursor (lb_linenum), the last line number (lb_botlin and inv_botlin).
768: It maintains an array of line breaks for display (inv_lbreaks).
769: This handles expanding tabs for display and displaying meta characters. */
770: lb_linenum = 0;
771: #if defined (HANDLE_MULTIBYTE)
772: in = 0;
773: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
774: {
775: memset (&ps, 0, sizeof (mbstate_t));
776: /* XXX - what if wc_bytes ends up <= 0? check for MB_INVALIDCH */
777: wc_bytes = mbrtowc (&wc, rl_line_buffer, rl_end, &ps);
778: }
779: else
780: wc_bytes = 1;
781: while (in < rl_end)
782: #else
783: for (in = 0; in < rl_end; in++)
784: #endif
785: {
786: c = (unsigned char)rl_line_buffer[in];
787:
788: #if defined (HANDLE_MULTIBYTE)
789: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
790: {
791: if (MB_INVALIDCH (wc_bytes))
792: {
793: /* Byte sequence is invalid or shortened. Assume that the
794: first byte represents a character. */
795: wc_bytes = 1;
796: /* Assume that a character occupies a single column. */
797: wc_width = 1;
798: memset (&ps, 0, sizeof (mbstate_t));
799: }
800: else if (MB_NULLWCH (wc_bytes))
801: break; /* Found '\0' */
802: else
803: {
804: temp = WCWIDTH (wc);
805: wc_width = (temp >= 0) ? temp : 1;
806: }
807: }
808: #endif
809:
810: if (out + 8 >= line_size) /* XXX - 8 for \t */
811: {
812: line_size *= 2;
813: visible_line = (char *)xrealloc (visible_line, line_size);
814: invisible_line = (char *)xrealloc (invisible_line, line_size);
815: line = invisible_line;
816: }
817:
818: if (in == rl_point)
819: {
820: cpos_buffer_position = out;
821: lb_linenum = newlines;
822: }
823:
824: #if defined (HANDLE_MULTIBYTE)
825: if (META_CHAR (c) && _rl_output_meta_chars == 0) /* XXX - clean up */
826: #else
827: if (META_CHAR (c))
828: #endif
829: {
830: if (_rl_output_meta_chars == 0)
831: {
832: sprintf (line + out, "\\%o", c);
833:
834: if (lpos + 4 >= _rl_screenwidth)
835: {
836: temp = _rl_screenwidth - lpos;
837: CHECK_INV_LBREAKS ();
838: inv_lbreaks[++newlines] = out + temp;
839: lpos = 4 - temp;
840: }
841: else
842: lpos += 4;
843:
844: out += 4;
845: }
846: else
847: {
848: line[out++] = c;
849: CHECK_LPOS();
850: }
851: }
852: #if defined (DISPLAY_TABS)
853: else if (c == '\t')
854: {
855: register int newout;
856:
857: #if 0
858: newout = (out | (int)7) + 1;
859: #else
860: newout = out + 8 - lpos % 8;
861: #endif
862: temp = newout - out;
863: if (lpos + temp >= _rl_screenwidth)
864: {
865: register int temp2;
866: temp2 = _rl_screenwidth - lpos;
867: CHECK_INV_LBREAKS ();
868: inv_lbreaks[++newlines] = out + temp2;
869: lpos = temp - temp2;
870: while (out < newout)
871: line[out++] = ' ';
872: }
873: else
874: {
875: while (out < newout)
876: line[out++] = ' ';
877: lpos += temp;
878: }
879: }
880: #endif
881: else if (c == '\n' && _rl_horizontal_scroll_mode == 0 && _rl_term_up && *_rl_term_up)
882: {
883: line[out++] = '\0'; /* XXX - sentinel */
884: CHECK_INV_LBREAKS ();
885: inv_lbreaks[++newlines] = out;
886: lpos = 0;
887: }
888: else if (CTRL_CHAR (c) || c == RUBOUT)
889: {
890: line[out++] = '^';
891: CHECK_LPOS();
892: line[out++] = CTRL_CHAR (c) ? UNCTRL (c) : '?';
893: CHECK_LPOS();
894: }
895: else
896: {
897: #if defined (HANDLE_MULTIBYTE)
898: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
899: {
900: register int i;
901:
902: _rl_wrapped_multicolumn = 0;
903:
904: if (_rl_screenwidth < lpos + wc_width)
905: for (i = lpos; i < _rl_screenwidth; i++)
906: {
907: /* The space will be removed in update_line() */
908: line[out++] = ' ';
909: _rl_wrapped_multicolumn++;
910: CHECK_LPOS();
911: }
912: if (in == rl_point)
913: {
914: cpos_buffer_position = out;
915: lb_linenum = newlines;
916: }
917: for (i = in; i < in+wc_bytes; i++)
918: line[out++] = rl_line_buffer[i];
919: for (i = 0; i < wc_width; i++)
920: CHECK_LPOS();
921: }
922: else
923: {
924: line[out++] = c;
925: CHECK_LPOS();
926: }
927: #else
928: line[out++] = c;
929: CHECK_LPOS();
930: #endif
931: }
932:
933: #if defined (HANDLE_MULTIBYTE)
934: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
935: {
936: in += wc_bytes;
937: /* XXX - what if wc_bytes ends up <= 0? check for MB_INVALIDCH */
938: wc_bytes = mbrtowc (&wc, rl_line_buffer + in, rl_end - in, &ps);
939: }
940: else
941: in++;
942: #endif
943:
944: }
945: line[out] = '\0';
946: if (cpos_buffer_position < 0)
947: {
948: cpos_buffer_position = out;
949: lb_linenum = newlines;
950: }
951:
952: inv_botlin = lb_botlin = newlines;
953: CHECK_INV_LBREAKS ();
954: inv_lbreaks[newlines+1] = out;
955: cursor_linenum = lb_linenum;
956:
957: /* CPOS_BUFFER_POSITION == position in buffer where cursor should be placed.
958: CURSOR_LINENUM == line number where the cursor should be placed. */
959:
960: /* PWP: now is when things get a bit hairy. The visible and invisible
961: line buffers are really multiple lines, which would wrap every
962: (screenwidth - 1) characters. Go through each in turn, finding
963: the changed region and updating it. The line order is top to bottom. */
964:
965: /* If we can move the cursor up and down, then use multiple lines,
966: otherwise, let long lines display in a single terminal line, and
967: horizontally scroll it. */
968: displaying_prompt_first_line = 1;
969: if (_rl_horizontal_scroll_mode == 0 && _rl_term_up && *_rl_term_up)
970: {
971: int nleft, pos, changed_screen_line, tx;
972:
973: if (!rl_display_fixed || forced_display)
974: {
975: forced_display = 0;
976:
977: /* If we have more than a screenful of material to display, then
978: only display a screenful. We should display the last screen,
979: not the first. */
980: if (out >= _rl_screenchars)
981: {
982: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
983: out = _rl_find_prev_mbchar (line, _rl_screenchars, MB_FIND_ANY);
984: else
985: out = _rl_screenchars - 1;
986: }
987:
988: /* The first line is at character position 0 in the buffer. The
989: second and subsequent lines start at inv_lbreaks[N], offset by
990: OFFSET (which has already been calculated above). */
991:
992: #define INVIS_FIRST() (prompt_physical_chars > _rl_screenwidth ? prompt_invis_chars_first_line : wrap_offset)
993: #define WRAP_OFFSET(line, offset) ((line == 0) \
994: ? (offset ? INVIS_FIRST() : 0) \
995: : ((line == prompt_last_screen_line) ? wrap_offset-prompt_invis_chars_first_line : 0))
996: #define W_OFFSET(line, offset) ((line) == 0 ? offset : 0)
997: #define VIS_LLEN(l) ((l) > _rl_vis_botlin ? 0 : (vis_lbreaks[l+1] - vis_lbreaks[l]))
998: #define INV_LLEN(l) (inv_lbreaks[l+1] - inv_lbreaks[l])
999: #define VIS_CHARS(line) (visible_line + vis_lbreaks[line])
1000: #define VIS_LINE(line) ((line) > _rl_vis_botlin) ? "" : VIS_CHARS(line)
1001: #define INV_LINE(line) (invisible_line + inv_lbreaks[line])
1002:
1003: #define OLD_CPOS_IN_PROMPT() (cpos_adjusted == 0 && \
1004: _rl_last_c_pos != o_cpos && \
1005: _rl_last_c_pos > wrap_offset && \
1006: o_cpos < prompt_last_invisible)
1007:
1008: /* For each line in the buffer, do the updating display. */
1009: for (linenum = 0; linenum <= inv_botlin; linenum++)
1010: {
1011: /* This can lead us astray if we execute a program that changes
1012: the locale from a non-multibyte to a multibyte one. */
1013: o_cpos = _rl_last_c_pos;
1014: cpos_adjusted = 0;
1015: update_line (VIS_LINE(linenum), INV_LINE(linenum), linenum,
1016: VIS_LLEN(linenum), INV_LLEN(linenum), inv_botlin);
1017:
1018: /* update_line potentially changes _rl_last_c_pos, but doesn't
1019: take invisible characters into account, since _rl_last_c_pos
1020: is an absolute cursor position in a multibyte locale. See
1021: if compensating here is the right thing, or if we have to
1022: change update_line itself. There are several cases in which
1023: update_line adjusts _rl_last_c_pos itself (so it can pass
1024: _rl_move_cursor_relative accurate values); it communicates
1025: this back by setting cpos_adjusted. If we assume that
1026: _rl_last_c_pos is correct (an absolute cursor position) each
1027: time update_line is called, then we can assume in our
1028: calculations that o_cpos does not need to be adjusted by
1029: wrap_offset. */
1030: if (linenum == 0 && (MB_CUR_MAX > 1 && rl_byte_oriented == 0) && OLD_CPOS_IN_PROMPT())
1031: _rl_last_c_pos -= prompt_invis_chars_first_line; /* XXX - was wrap_offset */
1032: else if (linenum == prompt_last_screen_line && prompt_physical_chars > _rl_screenwidth &&
1033: (MB_CUR_MAX > 1 && rl_byte_oriented == 0) &&
1034: cpos_adjusted == 0 &&
1035: _rl_last_c_pos != o_cpos &&
1036: _rl_last_c_pos > (prompt_last_invisible - _rl_screenwidth - prompt_invis_chars_first_line))
1037: _rl_last_c_pos -= (wrap_offset-prompt_invis_chars_first_line);
1038:
1039: /* If this is the line with the prompt, we might need to
1040: compensate for invisible characters in the new line. Do
1041: this only if there is not more than one new line (which
1042: implies that we completely overwrite the old visible line)
1043: and the new line is shorter than the old. Make sure we are
1044: at the end of the new line before clearing. */
1045: if (linenum == 0 &&
1046: inv_botlin == 0 && _rl_last_c_pos == out &&
1047: (wrap_offset > visible_wrap_offset) &&
1048: (_rl_last_c_pos < visible_first_line_len))
1049: {
1050: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1051: nleft = _rl_screenwidth - _rl_last_c_pos;
1052: else
1053: nleft = _rl_screenwidth + wrap_offset - _rl_last_c_pos;
1054: if (nleft)
1055: _rl_clear_to_eol (nleft);
1056: }
1057: #if 0
1058: /* This segment is intended to handle the case where the prompt
1059: has invisible characters on the second line and the new line
1060: to be displayed needs to clear the rest of the old characters
1061: out (e.g., when printing the i-search prompt). In general,
1062: the case of the new line being shorter than the old.
1063: Incomplete */
1064: else if (linenum == prompt_last_screen_line &&
1065: prompt_physical_chars > _rl_screenwidth &&
1066: wrap_offset != prompt_invis_chars_first_line &&
1067: _rl_last_c_pos == out &&
1068: #endif
1069:
1070:
1071: /* Since the new first line is now visible, save its length. */
1072: if (linenum == 0)
1073: visible_first_line_len = (inv_botlin > 0) ? inv_lbreaks[1] : out - wrap_offset;
1074: }
1075:
1076: /* We may have deleted some lines. If so, clear the left over
1077: blank ones at the bottom out. */
1078: if (_rl_vis_botlin > inv_botlin)
1079: {
1080: char *tt;
1081: for (; linenum <= _rl_vis_botlin; linenum++)
1082: {
1083: tt = VIS_CHARS (linenum);
1084: _rl_move_vert (linenum);
1085: _rl_move_cursor_relative (0, tt);
1086: _rl_clear_to_eol
1087: ((linenum == _rl_vis_botlin) ? strlen (tt) : _rl_screenwidth);
1088: }
1089: }
1090: _rl_vis_botlin = inv_botlin;
1091:
1092: /* CHANGED_SCREEN_LINE is set to 1 if we have moved to a
1093: different screen line during this redisplay. */
1094: changed_screen_line = _rl_last_v_pos != cursor_linenum;
1095: if (changed_screen_line)
1096: {
1097: _rl_move_vert (cursor_linenum);
1098: /* If we moved up to the line with the prompt using _rl_term_up,
1099: the physical cursor position on the screen stays the same,
1100: but the buffer position needs to be adjusted to account
1101: for invisible characters. */
1102: if ((MB_CUR_MAX == 1 || rl_byte_oriented) && cursor_linenum == 0 && wrap_offset)
1103: _rl_last_c_pos += wrap_offset;
1104: }
1105:
1106: /* We have to reprint the prompt if it contains invisible
1107: characters, since it's not generally OK to just reprint
1108: the characters from the current cursor position. But we
1109: only need to reprint it if the cursor is before the last
1110: invisible character in the prompt string. */
1111: nleft = prompt_visible_length + wrap_offset;
1112: if (cursor_linenum == 0 && wrap_offset > 0 && _rl_last_c_pos > 0 &&
1113: #if 0
1114: _rl_last_c_pos <= PROMPT_ENDING_INDEX && local_prompt)
1115: #else
1116: _rl_last_c_pos < PROMPT_ENDING_INDEX && local_prompt)
1117: #endif
1118: {
1119: #if defined (__MSDOS__)
1120: putc ('\r', rl_outstream);
1121: #else
1122: if (_rl_term_cr)
1123: tputs (_rl_term_cr, 1, _rl_output_character_function);
1124: #endif
1125: if (modmark)
1126: _rl_output_some_chars ("*", 1);
1127:
1128: _rl_output_some_chars (local_prompt, nleft);
1129: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1130: _rl_last_c_pos = _rl_col_width (local_prompt, 0, nleft, 1) - wrap_offset + modmark;
1131: else
1132: _rl_last_c_pos = nleft + modmark;
1133: }
1134:
1135: /* Where on that line? And where does that line start
1136: in the buffer? */
1137: pos = inv_lbreaks[cursor_linenum];
1138: /* nleft == number of characters in the line buffer between the
1139: start of the line and the desired cursor position. */
1140: nleft = cpos_buffer_position - pos;
1141:
1142: /* NLEFT is now a number of characters in a buffer. When in a
1143: multibyte locale, however, _rl_last_c_pos is an absolute cursor
1144: position that doesn't take invisible characters in the prompt
1145: into account. We use a fudge factor to compensate. */
1146:
1147: /* Since _rl_backspace() doesn't know about invisible characters in the
1148: prompt, and there's no good way to tell it, we compensate for
1149: those characters here and call _rl_backspace() directly. */
1150: if (wrap_offset && cursor_linenum == 0 && nleft < _rl_last_c_pos)
1151: {
1152: /* TX == new physical cursor position in multibyte locale. */
1153: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1154: tx = _rl_col_width (&visible_line[pos], 0, nleft, 1) - visible_wrap_offset;
1155: else
1156: tx = nleft;
1157: if (tx >= 0 && _rl_last_c_pos > tx)
1158: {
1159: _rl_backspace (_rl_last_c_pos - tx); /* XXX */
1160: _rl_last_c_pos = tx;
1161: }
1162: }
1163:
1164: /* We need to note that in a multibyte locale we are dealing with
1165: _rl_last_c_pos as an absolute cursor position, but moving to a
1166: point specified by a buffer position (NLEFT) that doesn't take
1167: invisible characters into account. */
1168: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1169: _rl_move_cursor_relative (nleft, &invisible_line[pos]);
1170: else if (nleft != _rl_last_c_pos)
1171: _rl_move_cursor_relative (nleft, &invisible_line[pos]);
1172: }
1173: }
1174: else /* Do horizontal scrolling. */
1175: {
1176: #define M_OFFSET(margin, offset) ((margin) == 0 ? offset : 0)
1177: int lmargin, ndisp, nleft, phys_c_pos, t;
1178:
1179: /* Always at top line. */
1180: _rl_last_v_pos = 0;
1181:
1182: /* Compute where in the buffer the displayed line should start. This
1183: will be LMARGIN. */
1184:
1185: /* The number of characters that will be displayed before the cursor. */
1186: ndisp = cpos_buffer_position - wrap_offset;
1187: nleft = prompt_visible_length + wrap_offset;
1188: /* Where the new cursor position will be on the screen. This can be
1189: longer than SCREENWIDTH; if it is, lmargin will be adjusted. */
1190: phys_c_pos = cpos_buffer_position - (last_lmargin ? last_lmargin : wrap_offset);
1191: t = _rl_screenwidth / 3;
1192:
1193: /* If the number of characters had already exceeded the screenwidth,
1194: last_lmargin will be > 0. */
1195:
1196: /* If the number of characters to be displayed is more than the screen
1197: width, compute the starting offset so that the cursor is about
1198: two-thirds of the way across the screen. */
1199: if (phys_c_pos > _rl_screenwidth - 2)
1200: {
1201: lmargin = cpos_buffer_position - (2 * t);
1202: if (lmargin < 0)
1203: lmargin = 0;
1204: /* If the left margin would be in the middle of a prompt with
1205: invisible characters, don't display the prompt at all. */
1206: if (wrap_offset && lmargin > 0 && lmargin < nleft)
1207: lmargin = nleft;
1208: }
1209: else if (ndisp < _rl_screenwidth - 2) /* XXX - was -1 */
1210: lmargin = 0;
1211: else if (phys_c_pos < 1)
1212: {
1213: /* If we are moving back towards the beginning of the line and
1214: the last margin is no longer correct, compute a new one. */
1215: lmargin = ((cpos_buffer_position - 1) / t) * t; /* XXX */
1216: if (wrap_offset && lmargin > 0 && lmargin < nleft)
1217: lmargin = nleft;
1218: }
1219: else
1220: lmargin = last_lmargin;
1221:
1222: displaying_prompt_first_line = lmargin < nleft;
1223:
1224: /* If the first character on the screen isn't the first character
1225: in the display line, indicate this with a special character. */
1226: if (lmargin > 0)
1227: line[lmargin] = '<';
1228:
1229: /* If SCREENWIDTH characters starting at LMARGIN do not encompass
1230: the whole line, indicate that with a special character at the
1231: right edge of the screen. If LMARGIN is 0, we need to take the
1232: wrap offset into account. */
1233: t = lmargin + M_OFFSET (lmargin, wrap_offset) + _rl_screenwidth;
1234: if (t < out)
1235: line[t - 1] = '>';
1236:
1237: if (rl_display_fixed == 0 || forced_display || lmargin != last_lmargin)
1238: {
1239: forced_display = 0;
1240: o_cpos = _rl_last_c_pos;
1241: cpos_adjusted = 0;
1242: update_line (&visible_line[last_lmargin],
1243: &invisible_line[lmargin],
1244: 0,
1245: _rl_screenwidth + visible_wrap_offset,
1246: _rl_screenwidth + (lmargin ? 0 : wrap_offset),
1247: 0);
1248:
1249: if ((MB_CUR_MAX > 1 && rl_byte_oriented == 0) &&
1250: displaying_prompt_first_line && OLD_CPOS_IN_PROMPT())
1251: _rl_last_c_pos -= prompt_invis_chars_first_line; /* XXX - was wrap_offset */
1252:
1253: /* If the visible new line is shorter than the old, but the number
1254: of invisible characters is greater, and we are at the end of
1255: the new line, we need to clear to eol. */
1256: t = _rl_last_c_pos - M_OFFSET (lmargin, wrap_offset);
1257: if ((M_OFFSET (lmargin, wrap_offset) > visible_wrap_offset) &&
1258: (_rl_last_c_pos == out) && displaying_prompt_first_line &&
1259: t < visible_first_line_len)
1260: {
1261: nleft = _rl_screenwidth - t;
1262: _rl_clear_to_eol (nleft);
1263: }
1264: visible_first_line_len = out - lmargin - M_OFFSET (lmargin, wrap_offset);
1265: if (visible_first_line_len > _rl_screenwidth)
1266: visible_first_line_len = _rl_screenwidth;
1267:
1268: _rl_move_cursor_relative (cpos_buffer_position - lmargin, &invisible_line[lmargin]);
1269: last_lmargin = lmargin;
1270: }
1271: }
1272: fflush (rl_outstream);
1273:
1274: /* Swap visible and non-visible lines. */
1275: {
1276: struct line_state *vtemp = line_state_visible;
1277:
1278: line_state_visible = line_state_invisible;
1279: line_state_invisible = vtemp;
1280:
1281: rl_display_fixed = 0;
1282: /* If we are displaying on a single line, and last_lmargin is > 0, we
1283: are not displaying any invisible characters, so set visible_wrap_offset
1284: to 0. */
1285: if (_rl_horizontal_scroll_mode && last_lmargin)
1286: visible_wrap_offset = 0;
1287: else
1288: visible_wrap_offset = wrap_offset;
1289: }
1290:
1291: RL_UNSETSTATE (RL_STATE_REDISPLAYING);
1292: _rl_release_sigint ();
1293: }
1294:
1295: /* PWP: update_line() is based on finding the middle difference of each
1296: line on the screen; vis:
1297:
1298: /old first difference
1299: /beginning of line | /old last same /old EOL
1300: v v v v
1301: old: eddie> Oh, my little gruntle-buggy is to me, as lurgid as
1302: new: eddie> Oh, my little buggy says to me, as lurgid as
1303: ^ ^ ^ ^
1304: \beginning of line | \new last same \new end of line
1305: \new first difference
1306:
1307: All are character pointers for the sake of speed. Special cases for
1308: no differences, as well as for end of line additions must be handled.
1309:
1310: Could be made even smarter, but this works well enough */
1311: static void
1312: update_line (old, new, current_line, omax, nmax, inv_botlin)
1313: register char *old, *new;
1314: int current_line, omax, nmax, inv_botlin;
1315: {
1316: register char *ofd, *ols, *oe, *nfd, *nls, *ne;
1317: int temp, lendiff, wsatend, od, nd, twidth, o_cpos;
1318: int current_invis_chars;
1319: int col_lendiff, col_temp;
1320: int bytes_to_insert;
1321: #if defined (HANDLE_MULTIBYTE)
1322: mbstate_t ps_new, ps_old;
1323: int new_offset, old_offset;
1324: #endif
1325:
1326: /* If we're at the right edge of a terminal that supports xn, we're
1327: ready to wrap around, so do so. This fixes problems with knowing
1328: the exact cursor position and cut-and-paste with certain terminal
1329: emulators. In this calculation, TEMP is the physical screen
1330: position of the cursor. */
1331: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1332: temp = _rl_last_c_pos;
1333: else
1334: temp = _rl_last_c_pos - WRAP_OFFSET (_rl_last_v_pos, visible_wrap_offset);
1335: if (temp == _rl_screenwidth && _rl_term_autowrap && !_rl_horizontal_scroll_mode
1336: && _rl_last_v_pos == current_line - 1)
1337: {
1338: #if defined (HANDLE_MULTIBYTE)
1339: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1340: {
1341: wchar_t wc;
1342: mbstate_t ps;
1343: int tempwidth, bytes;
1344: size_t ret;
1345:
1346: /* This fixes only double-column characters, but if the wrapped
1347: character consumes more than three columns, spaces will be
1348: inserted in the string buffer. */
1349: if (current_line < line_state_visible->wbsize && line_state_visible->wrapped_line[current_line] > 0)
1350: _rl_clear_to_eol (line_state_visible->wrapped_line[current_line]);
1351:
1352: memset (&ps, 0, sizeof (mbstate_t));
1353: ret = mbrtowc (&wc, new, MB_CUR_MAX, &ps);
1354: if (MB_INVALIDCH (ret))
1355: {
1356: tempwidth = 1;
1357: ret = 1;
1358: }
1359: else if (MB_NULLWCH (ret))
1360: tempwidth = 0;
1361: else
1362: tempwidth = WCWIDTH (wc);
1363:
1364: if (tempwidth > 0)
1365: {
1366: int count, i;
1367: bytes = ret;
1368: for (count = 0; count < bytes; count++)
1369: putc (new[count], rl_outstream);
1370: _rl_last_c_pos = tempwidth;
1371: _rl_last_v_pos++;
1372: memset (&ps, 0, sizeof (mbstate_t));
1373: ret = mbrtowc (&wc, old, MB_CUR_MAX, &ps);
1374: if (ret != 0 && bytes != 0)
1375: {
1376: if (MB_INVALIDCH (ret))
1377: ret = 1;
1378: memmove (old+bytes, old+ret, strlen (old+ret));
1379: memcpy (old, new, bytes);
1380: /* Fix up indices if we copy data from one line to another */
1381: omax += bytes - ret;
1382: for (i = current_line+1; i <= inv_botlin+1; i++)
1383: vis_lbreaks[i] += bytes - ret;
1384: }
1385: }
1386: else
1387: {
1388: putc (' ', rl_outstream);
1389: _rl_last_c_pos = 1;
1390: _rl_last_v_pos++;
1391: if (old[0] && new[0])
1392: old[0] = new[0];
1393: }
1394: }
1395: else
1396: #endif
1397: {
1398: if (new[0])
1399: putc (new[0], rl_outstream);
1400: else
1401: putc (' ', rl_outstream);
1402: _rl_last_c_pos = 1;
1403: _rl_last_v_pos++;
1404: if (old[0] && new[0])
1405: old[0] = new[0];
1406: }
1407: }
1408:
1409:
1410: /* Find first difference. */
1411: #if defined (HANDLE_MULTIBYTE)
1412: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1413: {
1414: /* See if the old line is a subset of the new line, so that the
1415: only change is adding characters. */
1416: temp = (omax < nmax) ? omax : nmax;
1417: if (memcmp (old, new, temp) == 0) /* adding at the end */
1418: {
1419: new_offset = old_offset = temp;
1420: ofd = old + temp;
1421: nfd = new + temp;
1422: }
1423: else
1424: {
1425: memset (&ps_new, 0, sizeof(mbstate_t));
1426: memset (&ps_old, 0, sizeof(mbstate_t));
1427:
1428: if (omax == nmax && STREQN (new, old, omax))
1429: {
1430: old_offset = omax;
1431: new_offset = nmax;
1432: ofd = old + omax;
1433: nfd = new + nmax;
1434: }
1435: else
1436: {
1437: new_offset = old_offset = 0;
1438: for (ofd = old, nfd = new;
1439: (ofd - old < omax) && *ofd &&
1440: _rl_compare_chars(old, old_offset, &ps_old, new, new_offset, &ps_new); )
1441: {
1442: old_offset = _rl_find_next_mbchar (old, old_offset, 1, MB_FIND_ANY);
1443: new_offset = _rl_find_next_mbchar (new, new_offset, 1, MB_FIND_ANY);
1444:
1445: ofd = old + old_offset;
1446: nfd = new + new_offset;
1447: }
1448: }
1449: }
1450: }
1451: else
1452: #endif
1453: for (ofd = old, nfd = new;
1454: (ofd - old < omax) && *ofd && (*ofd == *nfd);
1455: ofd++, nfd++)
1456: ;
1457:
1458: /* Move to the end of the screen line. ND and OD are used to keep track
1459: of the distance between ne and new and oe and old, respectively, to
1460: move a subtraction out of each loop. */
1461: for (od = ofd - old, oe = ofd; od < omax && *oe; oe++, od++);
1462: for (nd = nfd - new, ne = nfd; nd < nmax && *ne; ne++, nd++);
1463:
1464: /* If no difference, continue to next line. */
1465: if (ofd == oe && nfd == ne)
1466: return;
1467:
1468: #if defined (HANDLE_MULTIBYTE)
1469: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0 && _rl_utf8locale)
1470: {
1471: wchar_t wc;
1472: mbstate_t ps = { 0 };
1473: int t;
1474:
1475: /* If the first character in the difference is a zero-width character,
1476: assume it's a combining character and back one up so the two base
1477: characters no longer compare equivalently. */
1478: t = mbrtowc (&wc, ofd, MB_CUR_MAX, &ps);
1479: if (t > 0 && UNICODE_COMBINING_CHAR (wc) && WCWIDTH (wc) == 0)
1480: {
1481: old_offset = _rl_find_prev_mbchar (old, ofd - old, MB_FIND_ANY);
1482: new_offset = _rl_find_prev_mbchar (new, nfd - new, MB_FIND_ANY);
1483: ofd = old + old_offset; /* equal by definition */
1484: nfd = new + new_offset;
1485: }
1486: }
1487: #endif
1488:
1489: wsatend = 1; /* flag for trailing whitespace */
1490:
1491: #if defined (HANDLE_MULTIBYTE)
1492: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1493: {
1494: ols = old + _rl_find_prev_mbchar (old, oe - old, MB_FIND_ANY);
1495: nls = new + _rl_find_prev_mbchar (new, ne - new, MB_FIND_ANY);
1496:
1497: while ((ols > ofd) && (nls > nfd))
1498: {
1499: memset (&ps_old, 0, sizeof (mbstate_t));
1500: memset (&ps_new, 0, sizeof (mbstate_t));
1501:
1502: #if 0
1503: /* On advice from jir@yamato.ibm.com */
1504: _rl_adjust_point (old, ols - old, &ps_old);
1505: _rl_adjust_point (new, nls - new, &ps_new);
1506: #endif
1507:
1508: if (_rl_compare_chars (old, ols - old, &ps_old, new, nls - new, &ps_new) == 0)
1509: break;
1510:
1511: if (*ols == ' ')
1512: wsatend = 0;
1513:
1514: ols = old + _rl_find_prev_mbchar (old, ols - old, MB_FIND_ANY);
1515: nls = new + _rl_find_prev_mbchar (new, nls - new, MB_FIND_ANY);
1516: }
1517: }
1518: else
1519: {
1520: #endif /* HANDLE_MULTIBYTE */
1521: ols = oe - 1; /* find last same */
1522: nls = ne - 1;
1523: while ((ols > ofd) && (nls > nfd) && (*ols == *nls))
1524: {
1525: if (*ols != ' ')
1526: wsatend = 0;
1527: ols--;
1528: nls--;
1529: }
1530: #if defined (HANDLE_MULTIBYTE)
1531: }
1532: #endif
1533:
1534: if (wsatend)
1535: {
1536: ols = oe;
1537: nls = ne;
1538: }
1539: #if defined (HANDLE_MULTIBYTE)
1540: /* This may not work for stateful encoding, but who cares? To handle
1541: stateful encoding properly, we have to scan each string from the
1542: beginning and compare. */
1543: else if (_rl_compare_chars (ols, 0, NULL, nls, 0, NULL) == 0)
1544: #else
1545: else if (*ols != *nls)
1546: #endif
1547: {
1548: if (*ols) /* don't step past the NUL */
1549: {
1550: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1551: ols = old + _rl_find_next_mbchar (old, ols - old, 1, MB_FIND_ANY);
1552: else
1553: ols++;
1554: }
1555: if (*nls)
1556: {
1557: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1558: nls = new + _rl_find_next_mbchar (new, nls - new, 1, MB_FIND_ANY);
1559: else
1560: nls++;
1561: }
1562: }
1563:
1564: /* count of invisible characters in the current invisible line. */
1565: current_invis_chars = W_OFFSET (current_line, wrap_offset);
1566: if (_rl_last_v_pos != current_line)
1567: {
1568: _rl_move_vert (current_line);
1569: if ((MB_CUR_MAX == 1 || rl_byte_oriented) && current_line == 0 && visible_wrap_offset)
1570: _rl_last_c_pos += visible_wrap_offset;
1571: }
1572:
1573: /* If this is the first line and there are invisible characters in the
1574: prompt string, and the prompt string has not changed, and the current
1575: cursor position is before the last invisible character in the prompt,
1576: and the index of the character to move to is past the end of the prompt
1577: string, then redraw the entire prompt string. We can only do this
1578: reliably if the terminal supports a `cr' capability.
1579:
1580: This is not an efficiency hack -- there is a problem with redrawing
1581: portions of the prompt string if they contain terminal escape
1582: sequences (like drawing the `unbold' sequence without a corresponding
1583: `bold') that manifests itself on certain terminals. */
1584:
1585: lendiff = local_prompt_len;
1586: od = ofd - old; /* index of first difference in visible line */
1587: if (current_line == 0 && !_rl_horizontal_scroll_mode &&
1588: _rl_term_cr && lendiff > prompt_visible_length && _rl_last_c_pos > 0 &&
1589: od >= lendiff && _rl_last_c_pos < PROMPT_ENDING_INDEX)
1590: {
1591: #if defined (__MSDOS__)
1592: putc ('\r', rl_outstream);
1593: #else
1594: tputs (_rl_term_cr, 1, _rl_output_character_function);
1595: #endif
1596: if (modmark)
1597: _rl_output_some_chars ("*", 1);
1598: _rl_output_some_chars (local_prompt, lendiff);
1599: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1600: {
1601: /* We take wrap_offset into account here so we can pass correct
1602: information to _rl_move_cursor_relative. */
1603: _rl_last_c_pos = _rl_col_width (local_prompt, 0, lendiff, 1) - wrap_offset + modmark;
1604: cpos_adjusted = 1;
1605: }
1606: else
1607: _rl_last_c_pos = lendiff + modmark;
1608: }
1609:
1610: o_cpos = _rl_last_c_pos;
1611:
1612: /* When this function returns, _rl_last_c_pos is correct, and an absolute
1613: cursor position in multibyte mode, but a buffer index when not in a
1614: multibyte locale. */
1615: _rl_move_cursor_relative (od, old);
1616:
1617: #if defined (HANDLE_MULTIBYTE)
1618: /* We need to indicate that the cursor position is correct in the presence of
1619: invisible characters in the prompt string. Let's see if setting this when
1620: we make sure we're at the end of the drawn prompt string works. */
1621: if (current_line == 0 && MB_CUR_MAX > 1 && rl_byte_oriented == 0 &&
1622: (_rl_last_c_pos > 0 || o_cpos > 0) &&
1623: _rl_last_c_pos == prompt_physical_chars)
1624: cpos_adjusted = 1;
1625: #endif
1626:
1627: /* if (len (new) > len (old))
1628: lendiff == difference in buffer (bytes)
1629: col_lendiff == difference on screen (columns)
1630: When not using multibyte characters, these are equal */
1631: lendiff = (nls - nfd) - (ols - ofd);
1632: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1633: col_lendiff = _rl_col_width (new, nfd - new, nls - new, 1) - _rl_col_width (old, ofd - old, ols - old, 1);
1634: else
1635: col_lendiff = lendiff;
1636:
1637: /* If we are changing the number of invisible characters in a line, and
1638: the spot of first difference is before the end of the invisible chars,
1639: lendiff needs to be adjusted. */
1640: if (current_line == 0 && !_rl_horizontal_scroll_mode &&
1641: current_invis_chars != visible_wrap_offset)
1642: {
1643: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1644: {
1645: lendiff += visible_wrap_offset - current_invis_chars;
1646: col_lendiff += visible_wrap_offset - current_invis_chars;
1647: }
1648: else
1649: {
1650: lendiff += visible_wrap_offset - current_invis_chars;
1651: col_lendiff = lendiff;
1652: }
1653: }
1654:
1655: /* We use temp as a count of the number of bytes from the first difference
1656: to the end of the new line. col_temp is the corresponding number of
1657: screen columns. A `dumb' update moves to the spot of first difference
1658: and writes TEMP bytes. */
1659: /* Insert (diff (len (old), len (new)) ch. */
1660: temp = ne - nfd;
1661: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1662: col_temp = _rl_col_width (new, nfd - new, ne - new, 1);
1663: else
1664: col_temp = temp;
1665:
1666: /* how many bytes from the new line buffer to write to the display */
1667: bytes_to_insert = nls - nfd;
1668:
1669: /* col_lendiff > 0 if we are adding characters to the line */
1670: if (col_lendiff > 0) /* XXX - was lendiff */
1671: {
1672: /* Non-zero if we're increasing the number of lines. */
1673: int gl = current_line >= _rl_vis_botlin && inv_botlin > _rl_vis_botlin;
1674: /* If col_lendiff is > 0, implying that the new string takes up more
1675: screen real estate than the old, but lendiff is < 0, meaning that it
1676: takes fewer bytes, we need to just output the characters starting
1677: from the first difference. These will overwrite what is on the
1678: display, so there's no reason to do a smart update. This can really
1679: only happen in a multibyte environment. */
1680: if (lendiff < 0)
1681: {
1682: _rl_output_some_chars (nfd, temp);
1683: _rl_last_c_pos += col_temp; /* XXX - was _rl_col_width (nfd, 0, temp, 1); */
1684: /* If nfd begins before any invisible characters in the prompt,
1685: adjust _rl_last_c_pos to account for wrap_offset and set
1686: cpos_adjusted to let the caller know. */
1687: if (current_line == 0 && displaying_prompt_first_line && wrap_offset && ((nfd - new) <= prompt_last_invisible))
1688: {
1689: _rl_last_c_pos -= wrap_offset;
1690: cpos_adjusted = 1;
1691: }
1692: return;
1693: }
1694: /* Sometimes it is cheaper to print the characters rather than
1695: use the terminal's capabilities. If we're growing the number
1696: of lines, make sure we actually cause the new line to wrap
1697: around on auto-wrapping terminals. */
1698: else if (_rl_terminal_can_insert && ((2 * col_temp) >= col_lendiff || _rl_term_IC) && (!_rl_term_autowrap || !gl))
1699: {
1700: /* If lendiff > prompt_visible_length and _rl_last_c_pos == 0 and
1701: _rl_horizontal_scroll_mode == 1, inserting the characters with
1702: _rl_term_IC or _rl_term_ic will screw up the screen because of the
1703: invisible characters. We need to just draw them. */
1704: /* The same thing happens if we're trying to draw before the last
1705: invisible character in the prompt string or we're increasing the
1706: number of invisible characters in the line and we're not drawing
1707: the entire prompt string. */
1708: if (*ols && ((_rl_horizontal_scroll_mode &&
1709: _rl_last_c_pos == 0 &&
1710: lendiff > prompt_visible_length &&
1711: current_invis_chars > 0) == 0) &&
1712: (((MB_CUR_MAX > 1 && rl_byte_oriented == 0) &&
1713: current_line == 0 && wrap_offset &&
1714: ((nfd - new) <= prompt_last_invisible) &&
1715: (col_lendiff < prompt_visible_length)) == 0) &&
1716: (visible_wrap_offset >= current_invis_chars))
1717: {
1718: open_some_spaces (col_lendiff);
1719: _rl_output_some_chars (nfd, bytes_to_insert);
1720: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1721: _rl_last_c_pos += _rl_col_width (nfd, 0, bytes_to_insert, 1);
1722: else
1723: _rl_last_c_pos += bytes_to_insert;
1724: }
1725: else if ((MB_CUR_MAX == 1 || rl_byte_oriented != 0) && *ols == 0 && lendiff > 0)
1726: {
1727: /* At the end of a line the characters do not have to
1728: be "inserted". They can just be placed on the screen. */
1729: _rl_output_some_chars (nfd, temp);
1730: _rl_last_c_pos += col_temp;
1731: return;
1732: }
1733: else /* just write from first difference to end of new line */
1734: {
1735: _rl_output_some_chars (nfd, temp);
1736: _rl_last_c_pos += col_temp;
1737: /* If nfd begins before the last invisible character in the
1738: prompt, adjust _rl_last_c_pos to account for wrap_offset
1739: and set cpos_adjusted to let the caller know. */
1740: if ((MB_CUR_MAX > 1 && rl_byte_oriented == 0) && current_line == 0 && displaying_prompt_first_line && wrap_offset && ((nfd - new) <= prompt_last_invisible))
1741: {
1742: _rl_last_c_pos -= wrap_offset;
1743: cpos_adjusted = 1;
1744: }
1745: return;
1746: }
1747:
1748: if (bytes_to_insert > lendiff)
1749: {
1750: /* If nfd begins before the last invisible character in the
1751: prompt, adjust _rl_last_c_pos to account for wrap_offset
1752: and set cpos_adjusted to let the caller know. */
1753: if ((MB_CUR_MAX > 1 && rl_byte_oriented == 0) && current_line == 0 && displaying_prompt_first_line && wrap_offset && ((nfd - new) <= prompt_last_invisible))
1754: {
1755: _rl_last_c_pos -= wrap_offset;
1756: cpos_adjusted = 1;
1757: }
1758: }
1759: }
1760: else
1761: {
1762: /* cannot insert chars, write to EOL */
1763: _rl_output_some_chars (nfd, temp);
1764: _rl_last_c_pos += col_temp;
1765: /* If we're in a multibyte locale and were before the last invisible
1766: char in the current line (which implies we just output some invisible
1767: characters) we need to adjust _rl_last_c_pos, since it represents
1768: a physical character position. */
1769: if ((MB_CUR_MAX > 1 && rl_byte_oriented == 0) &&
1770: current_line == prompt_last_screen_line && wrap_offset &&
1771: displaying_prompt_first_line &&
1772: wrap_offset != prompt_invis_chars_first_line &&
1773: ((nfd-new) < (prompt_last_invisible-(current_line*_rl_screenwidth))))
1774: {
1775: _rl_last_c_pos -= wrap_offset - prompt_invis_chars_first_line;
1776: cpos_adjusted = 1;
1777: }
1778: }
1779: }
1780: else /* Delete characters from line. */
1781: {
1782: /* If possible and inexpensive to use terminal deletion, then do so. */
1783: if (_rl_term_dc && (2 * col_temp) >= -col_lendiff)
1784: {
1785: /* If all we're doing is erasing the invisible characters in the
1786: prompt string, don't bother. It screws up the assumptions
1787: about what's on the screen. */
1788: if (_rl_horizontal_scroll_mode && _rl_last_c_pos == 0 &&
1789: displaying_prompt_first_line &&
1790: -lendiff == visible_wrap_offset)
1791: col_lendiff = 0;
1792:
1793: /* If we have moved lmargin and we're shrinking the line, we've
1794: already moved the cursor to the first character of the new line,
1795: so deleting -col_lendiff characters will mess up the cursor
1796: position calculation */
1797: if (_rl_horizontal_scroll_mode && displaying_prompt_first_line == 0 &&
1798: col_lendiff && _rl_last_c_pos < -col_lendiff)
1799: col_lendiff = 0;
1800:
1801: if (col_lendiff)
1802: delete_chars (-col_lendiff); /* delete (diff) characters */
1803:
1804: /* Copy (new) chars to screen from first diff to last match,
1805: overwriting what is there. */
1806: if (bytes_to_insert > 0)
1807: {
1808: /* If nfd begins at the prompt, or before the invisible
1809: characters in the prompt, we need to adjust _rl_last_c_pos
1810: in a multibyte locale to account for the wrap offset and
1811: set cpos_adjusted accordingly. */
1812: _rl_output_some_chars (nfd, bytes_to_insert);
1813: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1814: {
1815: _rl_last_c_pos += _rl_col_width (nfd, 0, bytes_to_insert, 1);
1816: if (current_line == 0 && wrap_offset &&
1817: displaying_prompt_first_line &&
1818: _rl_last_c_pos > wrap_offset &&
1819: ((nfd - new) <= prompt_last_invisible))
1820: {
1821: _rl_last_c_pos -= wrap_offset;
1822: cpos_adjusted = 1;
1823: }
1824: }
1825: else
1826: _rl_last_c_pos += bytes_to_insert;
1827:
1828: if (_rl_horizontal_scroll_mode && ((oe-old) > (ne-new)))
1829: goto clear_rest_of_line;
1830: }
1831: }
1832: /* Otherwise, print over the existing material. */
1833: else
1834: {
1835: if (temp > 0)
1836: {
1837: /* If nfd begins at the prompt, or before the invisible
1838: characters in the prompt, we need to adjust _rl_last_c_pos
1839: in a multibyte locale to account for the wrap offset and
1840: set cpos_adjusted accordingly. */
1841: _rl_output_some_chars (nfd, temp);
1842: _rl_last_c_pos += col_temp; /* XXX */
1843: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1844: {
1845: if (current_line == 0 && wrap_offset &&
1846: displaying_prompt_first_line &&
1847: _rl_last_c_pos > wrap_offset &&
1848: ((nfd - new) <= prompt_last_invisible))
1849: {
1850: _rl_last_c_pos -= wrap_offset;
1851: cpos_adjusted = 1;
1852: }
1853: }
1854: }
1855: clear_rest_of_line:
1856: lendiff = (oe - old) - (ne - new);
1857: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1858: col_lendiff = _rl_col_width (old, 0, oe - old, 1) - _rl_col_width (new, 0, ne - new, 1);
1859: else
1860: col_lendiff = lendiff;
1861:
1862: /* If we've already printed over the entire width of the screen,
1863: including the old material, then col_lendiff doesn't matter and
1864: space_to_eol will insert too many spaces. XXX - maybe we should
1865: adjust col_lendiff based on the difference between _rl_last_c_pos
1866: and _rl_screenwidth */
1867: if (col_lendiff && ((MB_CUR_MAX == 1 || rl_byte_oriented) || (_rl_last_c_pos < _rl_screenwidth)))
1868: {
1869: if (_rl_term_autowrap && current_line < inv_botlin)
1870: space_to_eol (col_lendiff);
1871: else
1872: _rl_clear_to_eol (col_lendiff);
1873: }
1874: }
1875: }
1876: }
1877:
1878: /* Tell the update routines that we have moved onto a new (empty) line. */
1879: int
1880: rl_on_new_line ()
1881: {
1882: if (visible_line)
1883: visible_line[0] = '\0';
1884:
1885: _rl_last_c_pos = _rl_last_v_pos = 0;
1886: _rl_vis_botlin = last_lmargin = 0;
1887: if (vis_lbreaks)
1888: vis_lbreaks[0] = vis_lbreaks[1] = 0;
1889: visible_wrap_offset = 0;
1890: return 0;
1891: }
1892:
1893: /* Tell the update routines that we have moved onto a new line with the
1894: prompt already displayed. Code originally from the version of readline
1895: distributed with CLISP. rl_expand_prompt must have already been called
1896: (explicitly or implicitly). This still doesn't work exactly right. */
1897: int
1898: rl_on_new_line_with_prompt ()
1899: {
1900: int prompt_size, i, l, real_screenwidth, newlines;
1901: char *prompt_last_line, *lprompt;
1902:
1903: /* Initialize visible_line and invisible_line to ensure that they can hold
1904: the already-displayed prompt. */
1905: prompt_size = strlen (rl_prompt) + 1;
1906: init_line_structures (prompt_size);
1907:
1908: /* Make sure the line structures hold the already-displayed prompt for
1909: redisplay. */
1910: lprompt = local_prompt ? local_prompt : rl_prompt;
1911: strcpy (visible_line, lprompt);
1912: strcpy (invisible_line, lprompt);
1913:
1914: /* If the prompt contains newlines, take the last tail. */
1915: prompt_last_line = strrchr (rl_prompt, '\n');
1916: if (!prompt_last_line)
1917: prompt_last_line = rl_prompt;
1918:
1919: l = strlen (prompt_last_line);
1920: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1921: _rl_last_c_pos = _rl_col_width (prompt_last_line, 0, l, 1); /* XXX */
1922: else
1923: _rl_last_c_pos = l;
1924:
1925: /* Dissect prompt_last_line into screen lines. Note that here we have
1926: to use the real screenwidth. Readline's notion of screenwidth might be
1927: one less, see terminal.c. */
1928: real_screenwidth = _rl_screenwidth + (_rl_term_autowrap ? 0 : 1);
1929: _rl_last_v_pos = l / real_screenwidth;
1930: /* If the prompt length is a multiple of real_screenwidth, we don't know
1931: whether the cursor is at the end of the last line, or already at the
1932: beginning of the next line. Output a newline just to be safe. */
1933: if (l > 0 && (l % real_screenwidth) == 0)
1934: _rl_output_some_chars ("\n", 1);
1935: last_lmargin = 0;
1936:
1937: newlines = 0; i = 0;
1938: while (i <= l)
1939: {
1940: _rl_vis_botlin = newlines;
1941: vis_lbreaks[newlines++] = i;
1942: i += real_screenwidth;
1943: }
1944: vis_lbreaks[newlines] = l;
1945: visible_wrap_offset = 0;
1946:
1947: rl_display_prompt = rl_prompt; /* XXX - make sure it's set */
1948:
1949: return 0;
1950: }
1951:
1952: /* Actually update the display, period. */
1953: int
1954: rl_forced_update_display ()
1955: {
1956: register char *temp;
1957:
1958: if (visible_line)
1959: {
1960: temp = visible_line;
1961: while (*temp)
1962: *temp++ = '\0';
1963: }
1964: rl_on_new_line ();
1965: forced_display++;
1966: (*rl_redisplay_function) ();
1967: return 0;
1968: }
1969:
1970: /* Move the cursor from _rl_last_c_pos to NEW, which are buffer indices.
1971: (Well, when we don't have multibyte characters, _rl_last_c_pos is a
1972: buffer index.)
1973: DATA is the contents of the screen line of interest; i.e., where
1974: the movement is being done. */
1975: void
1976: _rl_move_cursor_relative (new, data)
1977: int new;
1978: const char *data;
1979: {
1980: register int i;
1981: int woff; /* number of invisible chars on current line */
1982: int cpos, dpos; /* current and desired cursor positions */
1983: int adjust;
1984:
1985: woff = WRAP_OFFSET (_rl_last_v_pos, wrap_offset);
1986: cpos = _rl_last_c_pos;
1987:
1988: if (cpos == 0 && cpos == new)
1989: return;
1990:
1991: #if defined (HANDLE_MULTIBYTE)
1992: /* If we have multibyte characters, NEW is indexed by the buffer point in
1993: a multibyte string, but _rl_last_c_pos is the display position. In
1994: this case, NEW's display position is not obvious and must be
1995: calculated. We need to account for invisible characters in this line,
1996: as long as we are past them and they are counted by _rl_col_width. */
1997: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1998: {
1999: adjust = 1;
2000: /* Try to short-circuit common cases and eliminate a bunch of multibyte
2001: character function calls. */
2002: /* 1. prompt string */
2003: if (new == local_prompt_len && memcmp (data, local_prompt, new) == 0)
2004: {
2005: dpos = prompt_physical_chars;
2006: cpos_adjusted = 1;
2007: adjust = 0;
2008: }
2009: /* 2. prompt_string + line contents */
2010: else if (new > local_prompt_len && local_prompt && memcmp (data, local_prompt, local_prompt_len) == 0)
2011: {
2012: dpos = prompt_physical_chars + _rl_col_width (data, local_prompt_len, new, 1);
2013: cpos_adjusted = 1;
2014: adjust = 0;
2015: }
2016: else
2017: dpos = _rl_col_width (data, 0, new, 1);
2018:
2019: if (displaying_prompt_first_line == 0)
2020: adjust = 0;
2021:
2022: /* Use NEW when comparing against the last invisible character in the
2023: prompt string, since they're both buffer indices and DPOS is a
2024: desired display position. */
2025: if (adjust && ((new > prompt_last_invisible) || /* XXX - don't use woff here */
2026: (prompt_physical_chars >= _rl_screenwidth &&
2027: _rl_last_v_pos == prompt_last_screen_line &&
2028: wrap_offset >= woff && dpos >= woff &&
2029: new > (prompt_last_invisible-(_rl_screenwidth*_rl_last_v_pos)-wrap_offset))))
2030: /* XXX last comparison might need to be >= */
2031: {
2032: dpos -= woff;
2033: /* Since this will be assigned to _rl_last_c_pos at the end (more
2034: precisely, _rl_last_c_pos == dpos when this function returns),
2035: let the caller know. */
2036: cpos_adjusted = 1;
2037: }
2038: }
2039: else
2040: #endif
2041: dpos = new;
2042:
2043: /* If we don't have to do anything, then return. */
2044: if (cpos == dpos)
2045: return;
2046:
2047: /* It may be faster to output a CR, and then move forwards instead
2048: of moving backwards. */
2049: /* i == current physical cursor position. */
2050: #if defined (HANDLE_MULTIBYTE)
2051: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
2052: i = _rl_last_c_pos;
2053: else
2054: #endif
2055: i = _rl_last_c_pos - woff;
2056: if (dpos == 0 || CR_FASTER (dpos, _rl_last_c_pos) ||
2057: (_rl_term_autowrap && i == _rl_screenwidth))
2058: {
2059: #if defined (__MSDOS__)
2060: putc ('\r', rl_outstream);
2061: #else
2062: tputs (_rl_term_cr, 1, _rl_output_character_function);
2063: #endif /* !__MSDOS__ */
2064: cpos = _rl_last_c_pos = 0;
2065: }
2066:
2067: if (cpos < dpos)
2068: {
2069: /* Move the cursor forward. We do it by printing the command
2070: to move the cursor forward if there is one, else print that
2071: portion of the output buffer again. Which is cheaper? */
2072:
2073: /* The above comment is left here for posterity. It is faster
2074: to print one character (non-control) than to print a control
2075: sequence telling the terminal to move forward one character.
2076: That kind of control is for people who don't know what the
2077: data is underneath the cursor. */
2078:
2079: /* However, we need a handle on where the current display position is
2080: in the buffer for the immediately preceding comment to be true.
2081: In multibyte locales, we don't currently have that info available.
2082: Without it, we don't know where the data we have to display begins
2083: in the buffer and we have to go back to the beginning of the screen
2084: line. In this case, we can use the terminal sequence to move forward
2085: if it's available. */
2086: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
2087: {
2088: if (_rl_term_forward_char)
2089: {
2090: for (i = cpos; i < dpos; i++)
2091: tputs (_rl_term_forward_char, 1, _rl_output_character_function);
2092: }
2093: else
2094: {
2095: tputs (_rl_term_cr, 1, _rl_output_character_function);
2096: for (i = 0; i < new; i++)
2097: putc (data[i], rl_outstream);
2098: }
2099: }
2100: else
2101: for (i = cpos; i < new; i++)
2102: putc (data[i], rl_outstream);
2103: }
2104:
2105: #if defined (HANDLE_MULTIBYTE)
2106: /* NEW points to the buffer point, but _rl_last_c_pos is the display point.
2107: The byte length of the string is probably bigger than the column width
2108: of the string, which means that if NEW == _rl_last_c_pos, then NEW's
2109: display point is less than _rl_last_c_pos. */
2110: #endif
2111: else if (cpos > dpos)
2112: _rl_backspace (cpos - dpos);
2113:
2114: _rl_last_c_pos = dpos;
2115: }
2116:
2117: /* PWP: move the cursor up or down. */
2118: void
2119: _rl_move_vert (to)
2120: int to;
2121: {
2122: register int delta, i;
2123:
2124: if (_rl_last_v_pos == to || to > _rl_screenheight)
2125: return;
2126:
2127: if ((delta = to - _rl_last_v_pos) > 0)
2128: {
2129: for (i = 0; i < delta; i++)
2130: putc ('\n', rl_outstream);
2131: #if defined (__MSDOS__)
2132: putc ('\r', rl_outstream);
2133: #else
2134: tputs (_rl_term_cr, 1, _rl_output_character_function);
2135: #endif
2136: _rl_last_c_pos = 0;
2137: }
2138: else
2139: { /* delta < 0 */
2140: #ifdef __DJGPP__
2141: int row, col;
2142:
2143: fflush (rl_outstream);
2144: ScreenGetCursor (&row, &col);
2145: ScreenSetCursor (row + delta, col);
2146: i = -delta;
2147: #else
2148: if (_rl_term_up && *_rl_term_up)
2149: for (i = 0; i < -delta; i++)
2150: tputs (_rl_term_up, 1, _rl_output_character_function);
2151: #endif /* !__DJGPP__ */
2152: }
2153:
2154: _rl_last_v_pos = to; /* Now TO is here */
2155: }
2156:
2157: /* Physically print C on rl_outstream. This is for functions which know
2158: how to optimize the display. Return the number of characters output. */
2159: int
2160: rl_show_char (c)
2161: int c;
2162: {
2163: int n = 1;
2164: if (META_CHAR (c) && (_rl_output_meta_chars == 0))
2165: {
2166: fprintf (rl_outstream, "M-");
2167: n += 2;
2168: c = UNMETA (c);
2169: }
2170:
2171: #if defined (DISPLAY_TABS)
2172: if ((CTRL_CHAR (c) && c != '\t') || c == RUBOUT)
2173: #else
2174: if (CTRL_CHAR (c) || c == RUBOUT)
2175: #endif /* !DISPLAY_TABS */
2176: {
2177: fprintf (rl_outstream, "C-");
2178: n += 2;
2179: c = CTRL_CHAR (c) ? UNCTRL (c) : '?';
2180: }
2181:
2182: putc (c, rl_outstream);
2183: fflush (rl_outstream);
2184: return n;
2185: }
2186:
2187: int
2188: rl_character_len (c, pos)
2189: register int c, pos;
2190: {
2191: unsigned char uc;
2192:
2193: uc = (unsigned char)c;
2194:
2195: if (META_CHAR (uc))
2196: return ((_rl_output_meta_chars == 0) ? 4 : 1);
2197:
2198: if (uc == '\t')
2199: {
2200: #if defined (DISPLAY_TABS)
2201: return (((pos | 7) + 1) - pos);
2202: #else
2203: return (2);
2204: #endif /* !DISPLAY_TABS */
2205: }
2206:
2207: if (CTRL_CHAR (c) || c == RUBOUT)
2208: return (2);
2209:
2210: return ((ISPRINT (uc)) ? 1 : 2);
2211: }
2212: /* How to print things in the "echo-area". The prompt is treated as a
2213: mini-modeline. */
2214: static int msg_saved_prompt = 0;
2215:
2216: #if defined (USE_VARARGS)
2217: int
2218: #if defined (PREFER_STDARG)
2219: rl_message (const char *format, ...)
2220: #else
2221: rl_message (va_alist)
2222: va_dcl
2223: #endif
2224: {
2225: va_list args;
2226: #if defined (PREFER_VARARGS)
2227: char *format;
2228: #endif
2229: #if defined (HAVE_VSNPRINTF)
2230: int bneed;
2231: #endif
2232:
2233: #if defined (PREFER_STDARG)
2234: va_start (args, format);
2235: #else
2236: va_start (args);
2237: format = va_arg (args, char *);
2238: #endif
2239:
2240: if (msg_buf == 0)
2241: msg_buf = xmalloc (msg_bufsiz = 128);
2242:
2243: #if defined (HAVE_VSNPRINTF)
2244: bneed = vsnprintf (msg_buf, msg_bufsiz - 1, format, args);
2245: if (bneed >= msg_bufsiz - 1)
2246: {
2247: msg_bufsiz = bneed + 1;
2248: msg_buf = xrealloc (msg_buf, msg_bufsiz);
2249: va_end (args);
2250:
2251: #if defined (PREFER_STDARG)
2252: va_start (args, format);
2253: #else
2254: va_start (args);
2255: format = va_arg (args, char *);
2256: #endif
2257: vsnprintf (msg_buf, msg_bufsiz - 1, format, args);
2258: }
2259: #else
2260: vsprintf (msg_buf, format, args);
2261: msg_buf[msg_bufsiz - 1] = '\0'; /* overflow? */
2262: #endif
2263: va_end (args);
2264:
2265: if (saved_local_prompt == 0)
2266: {
2267: rl_save_prompt ();
2268: msg_saved_prompt = 1;
2269: }
2270: else if (local_prompt != saved_local_prompt)
2271: {
2272: FREE (local_prompt);
2273: FREE (local_prompt_prefix);
2274: local_prompt = (char *)NULL;
2275: }
2276: rl_display_prompt = msg_buf;
2277: local_prompt = expand_prompt (msg_buf, &prompt_visible_length,
2278: &prompt_last_invisible,
2279: &prompt_invis_chars_first_line,
2280: &prompt_physical_chars);
2281: local_prompt_prefix = (char *)NULL;
2282: local_prompt_len = local_prompt ? strlen (local_prompt) : 0;
2283: (*rl_redisplay_function) ();
2284:
2285: return 0;
2286: }
2287: #else /* !USE_VARARGS */
2288: int
2289: rl_message (format, arg1, arg2)
2290: char *format;
2291: {
2292: if (msg_buf == 0)
2293: msg_buf = xmalloc (msg_bufsiz = 128);
2294:
2295: sprintf (msg_buf, format, arg1, arg2);
2296: msg_buf[msg_bufsiz - 1] = '\0'; /* overflow? */
2297:
2298: rl_display_prompt = msg_buf;
2299: if (saved_local_prompt == 0)
2300: {
2301: rl_save_prompt ();
2302: msg_saved_prompt = 1;
2303: }
2304: else if (local_prompt != saved_local_prompt)
2305: {
2306: FREE (local_prompt);
2307: FREE (local_prompt_prefix);
2308: local_prompt = (char *)NULL;
2309: }
2310: local_prompt = expand_prompt (msg_buf, &prompt_visible_length,
2311: &prompt_last_invisible,
2312: &prompt_invis_chars_first_line,
2313: &prompt_physical_chars);
2314: local_prompt_prefix = (char *)NULL;
2315: local_prompt_len = local_prompt ? strlen (local_prompt) : 0;
2316: (*rl_redisplay_function) ();
2317:
2318: return 0;
2319: }
2320: #endif /* !USE_VARARGS */
2321:
2322: /* How to clear things from the "echo-area". */
2323: int
2324: rl_clear_message ()
2325: {
2326: rl_display_prompt = rl_prompt;
2327: if (msg_saved_prompt)
2328: {
2329: rl_restore_prompt ();
2330: msg_saved_prompt = 0;
2331: }
2332: (*rl_redisplay_function) ();
2333: return 0;
2334: }
2335:
2336: int
2337: rl_reset_line_state ()
2338: {
2339: rl_on_new_line ();
2340:
2341: rl_display_prompt = rl_prompt ? rl_prompt : "";
2342: forced_display = 1;
2343: return 0;
2344: }
2345:
2346: void
2347: rl_save_prompt ()
2348: {
2349: saved_local_prompt = local_prompt;
2350: saved_local_prefix = local_prompt_prefix;
2351: saved_prefix_length = prompt_prefix_length;
2352: saved_local_length = local_prompt_len;
2353: saved_last_invisible = prompt_last_invisible;
2354: saved_visible_length = prompt_visible_length;
2355: saved_invis_chars_first_line = prompt_invis_chars_first_line;
2356: saved_physical_chars = prompt_physical_chars;
2357:
2358: local_prompt = local_prompt_prefix = (char *)0;
2359: local_prompt_len = 0;
2360: prompt_last_invisible = prompt_visible_length = prompt_prefix_length = 0;
2361: prompt_invis_chars_first_line = prompt_physical_chars = 0;
2362: }
2363:
2364: void
2365: rl_restore_prompt ()
2366: {
2367: FREE (local_prompt);
2368: FREE (local_prompt_prefix);
2369:
2370: local_prompt = saved_local_prompt;
2371: local_prompt_prefix = saved_local_prefix;
2372: local_prompt_len = saved_local_length;
2373: prompt_prefix_length = saved_prefix_length;
2374: prompt_last_invisible = saved_last_invisible;
2375: prompt_visible_length = saved_visible_length;
2376: prompt_invis_chars_first_line = saved_invis_chars_first_line;
2377: prompt_physical_chars = saved_physical_chars;
2378:
2379: /* can test saved_local_prompt to see if prompt info has been saved. */
2380: saved_local_prompt = saved_local_prefix = (char *)0;
2381: saved_local_length = 0;
2382: saved_last_invisible = saved_visible_length = saved_prefix_length = 0;
2383: saved_invis_chars_first_line = saved_physical_chars = 0;
2384: }
2385:
2386: char *
2387: _rl_make_prompt_for_search (pchar)
2388: int pchar;
2389: {
2390: int len;
2391: char *pmt, *p;
2392:
2393: rl_save_prompt ();
2394:
2395: /* We've saved the prompt, and can do anything with the various prompt
2396: strings we need before they're restored. We want the unexpanded
2397: portion of the prompt string after any final newline. */
2398: p = rl_prompt ? strrchr (rl_prompt, '\n') : 0;
2399: if (p == 0)
2400: {
2401: len = (rl_prompt && *rl_prompt) ? strlen (rl_prompt) : 0;
2402: pmt = (char *)xmalloc (len + 2);
2403: if (len)
2404: strcpy (pmt, rl_prompt);
2405: pmt[len] = pchar;
2406: pmt[len+1] = '\0';
2407: }
2408: else
2409: {
2410: p++;
2411: len = strlen (p);
2412: pmt = (char *)xmalloc (len + 2);
2413: if (len)
2414: strcpy (pmt, p);
2415: pmt[len] = pchar;
2416: pmt[len+1] = '\0';
2417: }
2418:
2419: /* will be overwritten by expand_prompt, called from rl_message */
2420: prompt_physical_chars = saved_physical_chars + 1;
2421: return pmt;
2422: }
2423:
2424: /* Quick redisplay hack when erasing characters at the end of the line. */
2425: void
2426: _rl_erase_at_end_of_line (l)
2427: int l;
2428: {
2429: register int i;
2430:
2431: _rl_backspace (l);
2432: for (i = 0; i < l; i++)
2433: putc (' ', rl_outstream);
2434: _rl_backspace (l);
2435: for (i = 0; i < l; i++)
2436: visible_line[--_rl_last_c_pos] = '\0';
2437: rl_display_fixed++;
2438: }
2439:
2440: /* Clear to the end of the line. COUNT is the minimum
2441: number of character spaces to clear, */
2442: void
2443: _rl_clear_to_eol (count)
2444: int count;
2445: {
2446: #ifndef __MSDOS__
2447: if (_rl_term_clreol)
2448: tputs (_rl_term_clreol, 1, _rl_output_character_function);
2449: else
2450: #endif
2451: if (count)
2452: space_to_eol (count);
2453: }
2454:
2455: /* Clear to the end of the line using spaces. COUNT is the minimum
2456: number of character spaces to clear, */
2457: static void
2458: space_to_eol (count)
2459: int count;
2460: {
2461: register int i;
2462:
2463: for (i = 0; i < count; i++)
2464: putc (' ', rl_outstream);
2465:
2466: _rl_last_c_pos += count;
2467: }
2468:
2469: void
2470: _rl_clear_screen ()
2471: {
2472: #ifndef __DJGPP__
2473: if (_rl_term_clrpag)
2474: tputs (_rl_term_clrpag, 1, _rl_output_character_function);
2475: else
2476: rl_crlf ();
2477: #else
2478: ScreenClear ();
2479: ScreenSetCursor (0, 0);
2480: #endif /* __DJGPP__ */
2481: }
2482:
2483: /* Insert COUNT characters from STRING to the output stream at column COL. */
2484: static void
2485: insert_some_chars (string, count, col)
2486: char *string;
2487: int count, col;
2488: {
2489: open_some_spaces (col);
2490: _rl_output_some_chars (string, count);
2491: }
2492:
2493: /* Insert COL spaces, keeping the cursor at the same position. We follow the
2494: ncurses documentation and use either im/ei with explicit spaces, or IC/ic
2495: by itself. We assume there will either be ei or we don't need to use it. */
2496: static void
2497: open_some_spaces (col)
2498: int col;
2499: {
2500: #if !defined (__MSDOS__) && !defined (__MINGW32__)
2501: char *buffer;
2502: register int i;
2503:
2504: /* If IC is defined, then we do not have to "enter" insert mode. */
2505: if (_rl_term_IC)
2506: {
2507: buffer = tgoto (_rl_term_IC, 0, col);
2508: tputs (buffer, 1, _rl_output_character_function);
2509: }
2510: else if (_rl_term_im && *_rl_term_im)
2511: {
2512: tputs (_rl_term_im, 1, _rl_output_character_function);
2513: /* just output the desired number of spaces */
2514: for (i = col; i--; )
2515: _rl_output_character_function (' ');
2516: /* If there is a string to turn off insert mode, use it now. */
2517: if (_rl_term_ei && *_rl_term_ei)
2518: tputs (_rl_term_ei, 1, _rl_output_character_function);
2519: /* and move back the right number of spaces */
2520: _rl_backspace (col);
2521: }
2522: else if (_rl_term_ic && *_rl_term_ic)
2523: {
2524: /* If there is a special command for inserting characters, then
2525: use that first to open up the space. */
2526: for (i = col; i--; )
2527: tputs (_rl_term_ic, 1, _rl_output_character_function);
2528: }
2529: #endif /* !__MSDOS__ && !__MINGW32__ */
2530: }
2531:
2532: /* Delete COUNT characters from the display line. */
2533: static void
2534: delete_chars (count)
2535: int count;
2536: {
2537: if (count > _rl_screenwidth) /* XXX */
2538: return;
2539:
2540: #if !defined (__MSDOS__) && !defined (__MINGW32__)
2541: if (_rl_term_DC && *_rl_term_DC)
2542: {
2543: char *buffer;
2544: buffer = tgoto (_rl_term_DC, count, count);
2545: tputs (buffer, count, _rl_output_character_function);
2546: }
2547: else
2548: {
2549: if (_rl_term_dc && *_rl_term_dc)
2550: while (count--)
2551: tputs (_rl_term_dc, 1, _rl_output_character_function);
2552: }
2553: #endif /* !__MSDOS__ && !__MINGW32__ */
2554: }
2555:
2556: void
2557: _rl_update_final ()
2558: {
2559: int full_lines;
2560:
2561: full_lines = 0;
2562: /* If the cursor is the only thing on an otherwise-blank last line,
2563: compensate so we don't print an extra CRLF. */
2564: if (_rl_vis_botlin && _rl_last_c_pos == 0 &&
2565: visible_line[vis_lbreaks[_rl_vis_botlin]] == 0)
2566: {
2567: _rl_vis_botlin--;
2568: full_lines = 1;
2569: }
2570: _rl_move_vert (_rl_vis_botlin);
2571: /* If we've wrapped lines, remove the final xterm line-wrap flag. */
2572: if (full_lines && _rl_term_autowrap && (VIS_LLEN(_rl_vis_botlin) == _rl_screenwidth))
2573: {
2574: char *last_line;
2575:
2576: last_line = &visible_line[vis_lbreaks[_rl_vis_botlin]];
2577: cpos_buffer_position = -1; /* don't know where we are in buffer */
2578: _rl_move_cursor_relative (_rl_screenwidth - 1, last_line); /* XXX */
2579: _rl_clear_to_eol (0);
2580: putc (last_line[_rl_screenwidth - 1], rl_outstream);
2581: }
2582: _rl_vis_botlin = 0;
2583: rl_crlf ();
2584: fflush (rl_outstream);
2585: rl_display_fixed++;
2586: }
2587:
2588: /* Move to the start of the current line. */
2589: static void
2590: cr ()
2591: {
2592: if (_rl_term_cr)
2593: {
2594: #if defined (__MSDOS__)
2595: putc ('\r', rl_outstream);
2596: #else
2597: tputs (_rl_term_cr, 1, _rl_output_character_function);
2598: #endif
2599: _rl_last_c_pos = 0;
2600: }
2601: }
2602:
2603: /* Redraw the last line of a multi-line prompt that may possibly contain
2604: terminal escape sequences. Called with the cursor at column 0 of the
2605: line to draw the prompt on. */
2606: static void
2607: redraw_prompt (t)
2608: char *t;
2609: {
2610: char *oldp;
2611:
2612: oldp = rl_display_prompt;
2613: rl_save_prompt ();
2614:
2615: rl_display_prompt = t;
2616: local_prompt = expand_prompt (t, &prompt_visible_length,
2617: &prompt_last_invisible,
2618: &prompt_invis_chars_first_line,
2619: &prompt_physical_chars);
2620: local_prompt_prefix = (char *)NULL;
2621: local_prompt_len = local_prompt ? strlen (local_prompt) : 0;
2622:
2623: rl_forced_update_display ();
2624:
2625: rl_display_prompt = oldp;
2626: rl_restore_prompt();
2627: }
2628:
2629: /* Redisplay the current line after a SIGWINCH is received. */
2630: void
2631: _rl_redisplay_after_sigwinch ()
2632: {
2633: char *t;
2634:
2635: /* Clear the last line (assuming that the screen size change will result in
2636: either more or fewer characters on that line only) and put the cursor at
2637: column 0. Make sure the right thing happens if we have wrapped to a new
2638: screen line. */
2639: if (_rl_term_cr)
2640: {
2641: _rl_move_vert (_rl_vis_botlin);
2642:
2643: #if defined (__MSDOS__)
2644: putc ('\r', rl_outstream);
2645: #else
2646: tputs (_rl_term_cr, 1, _rl_output_character_function);
2647: #endif
2648: _rl_last_c_pos = 0;
2649: #if defined (__MSDOS__)
2650: space_to_eol (_rl_screenwidth);
2651: putc ('\r', rl_outstream);
2652: #else
2653: if (_rl_term_clreol)
2654: tputs (_rl_term_clreol, 1, _rl_output_character_function);
2655: else
2656: {
2657: space_to_eol (_rl_screenwidth);
2658: tputs (_rl_term_cr, 1, _rl_output_character_function);
2659: }
2660: #endif
2661: if (_rl_last_v_pos > 0)
2662: _rl_move_vert (0);
2663: }
2664: else
2665: rl_crlf ();
2666:
2667: /* Redraw only the last line of a multi-line prompt. */
2668: t = strrchr (rl_display_prompt, '\n');
2669: if (t)
2670: redraw_prompt (++t);
2671: else
2672: rl_forced_update_display ();
2673: }
2674:
2675: void
2676: _rl_clean_up_for_exit ()
2677: {
2678: if (_rl_echoing_p)
2679: {
2680: _rl_move_vert (_rl_vis_botlin);
2681: _rl_vis_botlin = 0;
2682: fflush (rl_outstream);
2683: rl_restart_output (1, 0);
2684: }
2685: }
2686:
2687: void
2688: _rl_erase_entire_line ()
2689: {
2690: cr ();
2691: _rl_clear_to_eol (0);
2692: cr ();
2693: fflush (rl_outstream);
2694: }
2695:
2696: /* return the `current display line' of the cursor -- the number of lines to
2697: move up to get to the first screen line of the current readline line. */
2698: int
2699: _rl_current_display_line ()
2700: {
2701: int ret, nleft;
2702:
2703: /* Find out whether or not there might be invisible characters in the
2704: editing buffer. */
2705: if (rl_display_prompt == rl_prompt)
2706: nleft = _rl_last_c_pos - _rl_screenwidth - rl_visible_prompt_length;
2707: else
2708: nleft = _rl_last_c_pos - _rl_screenwidth;
2709:
2710: if (nleft > 0)
2711: ret = 1 + nleft / _rl_screenwidth;
2712: else
2713: ret = 0;
2714:
2715: return ret;
2716: }
2717:
2718: #if defined (HANDLE_MULTIBYTE)
2719: /* Calculate the number of screen columns occupied by STR from START to END.
2720: In the case of multibyte characters with stateful encoding, we have to
2721: scan from the beginning of the string to take the state into account. */
2722: static int
2723: _rl_col_width (str, start, end, flags)
2724: const char *str;
2725: int start, end, flags;
2726: {
2727: wchar_t wc;
2728: mbstate_t ps;
2729: int tmp, point, width, max;
2730:
2731: if (end <= start)
2732: return 0;
2733: if (MB_CUR_MAX == 1 || rl_byte_oriented)
2734: /* this can happen in some cases where it's inconvenient to check */
2735: return (end - start);
2736:
2737: memset (&ps, 0, sizeof (mbstate_t));
2738:
2739: point = 0;
2740: max = end;
2741:
2742: /* Try to short-circuit common cases. The adjustment to remove wrap_offset
2743: is done by the caller. */
2744: /* 1. prompt string */
2745: if (flags && start == 0 && end == local_prompt_len && memcmp (str, local_prompt, local_prompt_len) == 0)
2746: return (prompt_physical_chars + wrap_offset);
2747: /* 2. prompt string + line contents */
2748: else if (flags && start == 0 && local_prompt_len > 0 && end > local_prompt_len && local_prompt && memcmp (str, local_prompt, local_prompt_len) == 0)
2749: {
2750: tmp = prompt_physical_chars + wrap_offset;
2751: /* XXX - try to call ourselves recursively with non-prompt portion */
2752: tmp += _rl_col_width (str, local_prompt_len, end, flags);
2753: return (tmp);
2754: }
2755:
2756: while (point < start)
2757: {
2758: tmp = mbrlen (str + point, max, &ps);
2759: if (MB_INVALIDCH ((size_t)tmp))
2760: {
2761: /* In this case, the bytes are invalid or too short to compose a
2762: multibyte character, so we assume that the first byte represents
2763: a single character. */
2764: point++;
2765: max--;
2766:
2767: /* Clear the state of the byte sequence, because in this case the
2768: effect of mbstate is undefined. */
2769: memset (&ps, 0, sizeof (mbstate_t));
2770: }
2771: else if (MB_NULLWCH (tmp))
2772: break; /* Found '\0' */
2773: else
2774: {
2775: point += tmp;
2776: max -= tmp;
2777: }
2778: }
2779:
2780: /* If START is not a byte that starts a character, then POINT will be
2781: greater than START. In this case, assume that (POINT - START) gives
2782: a byte count that is the number of columns of difference. */
2783: width = point - start;
2784:
2785: while (point < end)
2786: {
2787: tmp = mbrtowc (&wc, str + point, max, &ps);
2788: if (MB_INVALIDCH ((size_t)tmp))
2789: {
2790: /* In this case, the bytes are invalid or too short to compose a
2791: multibyte character, so we assume that the first byte represents
2792: a single character. */
2793: point++;
2794: max--;
2795:
2796: /* and assume that the byte occupies a single column. */
2797: width++;
2798:
2799: /* Clear the state of the byte sequence, because in this case the
2800: effect of mbstate is undefined. */
2801: memset (&ps, 0, sizeof (mbstate_t));
2802: }
2803: else if (MB_NULLWCH (tmp))
2804: break; /* Found '\0' */
2805: else
2806: {
2807: point += tmp;
2808: max -= tmp;
2809: tmp = WCWIDTH(wc);
2810: width += (tmp >= 0) ? tmp : 1;
2811: }
2812: }
2813:
2814: width += point - end;
2815:
2816: return width;
2817: }
2818: #endif /* HANDLE_MULTIBYTE */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to display.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / readline