1 /* $NetBSD: refresh.c,v 1.37 2011/07/29 23:44:45 christos Exp $ */
4 * Copyright (c) 1992, 1993
5 * The Regents of the University of California. All rights reserved.
7 * This code is derived from software contributed to Berkeley by
8 * Christos Zoulas of Cornell University.
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. Neither the name of the University nor the names of its contributors
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 #if !defined(lint) && !defined(SCCSID)
38 static char sccsid
[] = "@(#)refresh.c 8.1 (Berkeley) 6/4/93";
41 #endif /* not lint && not SCCSID */
44 * refresh.c: Lower level screen refreshing functions
53 private void re_nextline(EditLine
*);
54 private void re_addc(EditLine
*, Int
);
55 private void re_update_line(EditLine
*, Char
*, Char
*, int);
56 private void re_insert (EditLine
*, Char
*, int, int, Char
*, int);
57 private void re_delete(EditLine
*, Char
*, int, int, int);
58 private void re_fastputc(EditLine
*, Int
);
59 private void re_clear_eol(EditLine
*, int, int, int);
60 private void re__strncopy(Char
*, Char
*, size_t);
61 private void re__copy_and_pad(Char
*, const Char
*, size_t);
64 private void re_printstr(EditLine
*, const char *, char *, char *);
65 #define __F el->el_errfile
66 #define ELRE_ASSERT(a, b, c) do \
67 if (/*CONSTCOND*/ a) { \
71 while (/*CONSTCOND*/0)
72 #define ELRE_DEBUG(a, b) ELRE_ASSERT(a,b,;)
75 * Print a string on the debugging pty
78 re_printstr(EditLine
*el
, const char *str
, char *f
, char *t
)
81 ELRE_DEBUG(1, (__F
, "%s:\"", str
));
83 ELRE_DEBUG(1, (__F
, "%c", *f
++ & 0177));
84 ELRE_DEBUG(1, (__F
, "\"\r\n"));
87 #define ELRE_ASSERT(a, b, c)
88 #define ELRE_DEBUG(a, b)
92 * Move to the next line or scroll
95 re_nextline(EditLine
*el
)
97 el
->el_refresh
.r_cursor
.h
= 0; /* reset it. */
100 * If we would overflow (input is longer than terminal size),
101 * emulate scroll by dropping first line and shuffling the rest.
102 * We do this via pointer shuffling - it's safe in this case
103 * and we avoid memcpy().
105 if (el
->el_refresh
.r_cursor
.v
+ 1 >= el
->el_terminal
.t_size
.v
) {
106 int i
, lins
= el
->el_terminal
.t_size
.v
;
107 Char
*firstline
= el
->el_vdisplay
[0];
109 for(i
= 1; i
< lins
; i
++)
110 el
->el_vdisplay
[i
- 1] = el
->el_vdisplay
[i
];
112 firstline
[0] = '\0'; /* empty the string */
113 el
->el_vdisplay
[i
- 1] = firstline
;
115 el
->el_refresh
.r_cursor
.v
++;
117 ELRE_ASSERT(el
->el_refresh
.r_cursor
.v
>= el
->el_terminal
.t_size
.v
,
118 (__F
, "\r\nre_putc: overflow! r_cursor.v == %d > %d\r\n",
119 el
->el_refresh
.r_cursor
.v
, el
->el_terminal
.t_size
.v
),
124 * Draw c, expanding tabs, control chars etc.
127 re_addc(EditLine
*el
, Int c
)
129 switch (ct_chr_class((Char
)c
)) {
130 case CHTYPE_TAB
: /* expand the tab */
133 if ((el
->el_refresh
.r_cursor
.h
& 07) == 0)
134 break; /* go until tab stop */
138 int oldv
= el
->el_refresh
.r_cursor
.v
;
139 re_putc(el
, '\0', 0); /* assure end of line */
140 if (oldv
== el
->el_refresh
.r_cursor
.v
) /* XXX */
148 Char visbuf
[VISUAL_WIDTH_MAX
];
150 ct_visual_char(visbuf
, VISUAL_WIDTH_MAX
, (Char
)c
);
151 for (i
= 0; n
-- > 0; ++i
)
152 re_putc(el
, visbuf
[i
], 1);
160 * Draw the character given
163 re_putc(EditLine
*el
, Int c
, int shift
)
166 ELRE_DEBUG(1, (__F
, "printing %5x '%c'\r\n", c
, c
));
168 while (shift
&& (el
->el_refresh
.r_cursor
.h
+ w
> el
->el_terminal
.t_size
.h
))
171 el
->el_vdisplay
[el
->el_refresh
.r_cursor
.v
]
172 [el
->el_refresh
.r_cursor
.h
] = c
;
173 /* assumes !shift is only used for single-column chars */
176 el
->el_vdisplay
[el
->el_refresh
.r_cursor
.v
]
177 [el
->el_refresh
.r_cursor
.h
+ i
] = MB_FILL_CHAR
;
182 el
->el_refresh
.r_cursor
.h
+= w
; /* advance to next place */
183 if (el
->el_refresh
.r_cursor
.h
>= el
->el_terminal
.t_size
.h
) {
184 /* assure end of line */
185 el
->el_vdisplay
[el
->el_refresh
.r_cursor
.v
][el
->el_terminal
.t_size
.h
]
193 * draws the new virtual screen image from the current input
194 * line, then goes line-by-line changing the real image to the new
195 * virtual image. The routine to re-draw a line can be replaced
196 * easily in hopes of a smarter one being placed there.
199 re_refresh(EditLine
*el
)
208 ELRE_DEBUG(1, (__F
, "el->el_line.buffer = :%s:\r\n",
209 el
->el_line
.buffer
));
211 /* reset the Drawing cursor */
212 el
->el_refresh
.r_cursor
.h
= 0;
213 el
->el_refresh
.r_cursor
.v
= 0;
215 /* temporarily draw rprompt to calculate its size */
216 prompt_print(el
, EL_RPROMPT
);
218 /* reset the Drawing cursor */
219 el
->el_refresh
.r_cursor
.h
= 0;
220 el
->el_refresh
.r_cursor
.v
= 0;
222 if (el
->el_line
.cursor
>= el
->el_line
.lastchar
) {
223 if (el
->el_map
.current
== el
->el_map
.alt
224 && el
->el_line
.lastchar
!= el
->el_line
.buffer
)
225 el
->el_line
.cursor
= el
->el_line
.lastchar
- 1;
227 el
->el_line
.cursor
= el
->el_line
.lastchar
;
230 cur
.h
= -1; /* set flag in case I'm not set */
233 prompt_print(el
, EL_PROMPT
);
235 /* draw the current input buffer */
237 termsz
= el
->el_terminal
.t_size
.h
* el
->el_terminal
.t_size
.v
;
238 if (el
->el_line
.lastchar
- el
->el_line
.buffer
> termsz
) {
240 * If line is longer than terminal, process only part
241 * of line which would influence display.
243 size_t rem
= (el
->el_line
.lastchar
-el
->el_line
.buffer
)%termsz
;
245 st
= el
->el_line
.lastchar
- rem
246 - (termsz
- (((rem
/ el
->el_terminal
.t_size
.v
) - 1)
247 * el
->el_terminal
.t_size
.v
));
250 st
= el
->el_line
.buffer
;
252 for (cp
= st
; cp
< el
->el_line
.lastchar
; cp
++) {
253 if (cp
== el
->el_line
.cursor
) {
256 cur
.h
= el
->el_refresh
.r_cursor
.h
;
257 cur
.v
= el
->el_refresh
.r_cursor
.v
;
258 /* handle being at a linebroken doublewidth char */
259 if (w
> 1 && el
->el_refresh
.r_cursor
.h
+ w
>
260 el
->el_terminal
.t_size
.h
) {
268 if (cur
.h
== -1) { /* if I haven't been set yet, I'm at the end */
269 cur
.h
= el
->el_refresh
.r_cursor
.h
;
270 cur
.v
= el
->el_refresh
.r_cursor
.v
;
272 rhdiff
= el
->el_terminal
.t_size
.h
- el
->el_refresh
.r_cursor
.h
-
273 el
->el_rprompt
.p_pos
.h
;
274 if (el
->el_rprompt
.p_pos
.h
&& !el
->el_rprompt
.p_pos
.v
&&
275 !el
->el_refresh
.r_cursor
.v
&& rhdiff
> 1) {
277 * have a right-hand side prompt that will fit
278 * on the end of the first line with at least
279 * one character gap to the input buffer.
281 while (--rhdiff
> 0) /* pad out with spaces */
283 prompt_print(el
, EL_RPROMPT
);
285 el
->el_rprompt
.p_pos
.h
= 0; /* flag "not using rprompt" */
286 el
->el_rprompt
.p_pos
.v
= 0;
289 re_putc(el
, '\0', 0); /* make line ended with NUL, no cursor shift */
291 el
->el_refresh
.r_newcv
= el
->el_refresh
.r_cursor
.v
;
294 "term.h=%d vcur.h=%d vcur.v=%d vdisplay[0]=\r\n:%80.80s:\r\n",
295 el
->el_terminal
.t_size
.h
, el
->el_refresh
.r_cursor
.h
,
296 el
->el_refresh
.r_cursor
.v
, ct_encode_string(el
->el_vdisplay
[0])));
298 ELRE_DEBUG(1, (__F
, "updating %d lines.\r\n", el
->el_refresh
.r_newcv
));
299 for (i
= 0; i
<= el
->el_refresh
.r_newcv
; i
++) {
300 /* NOTE THAT re_update_line MAY CHANGE el_display[i] */
301 re_update_line(el
, el
->el_display
[i
], el
->el_vdisplay
[i
], i
);
304 * Copy the new line to be the current one, and pad out with
305 * spaces to the full width of the terminal so that if we try
306 * moving the cursor by writing the character that is at the
307 * end of the screen line, it won't be a NUL or some old
310 re__copy_and_pad(el
->el_display
[i
], el
->el_vdisplay
[i
],
311 (size_t) el
->el_terminal
.t_size
.h
);
314 "\r\nel->el_refresh.r_cursor.v=%d,el->el_refresh.r_oldcv=%d i=%d\r\n",
315 el
->el_refresh
.r_cursor
.v
, el
->el_refresh
.r_oldcv
, i
));
317 if (el
->el_refresh
.r_oldcv
> el
->el_refresh
.r_newcv
)
318 for (; i
<= el
->el_refresh
.r_oldcv
; i
++) {
319 terminal_move_to_line(el
, i
);
320 terminal_move_to_char(el
, 0);
321 /* This Strlen should be safe even with MB_FILL_CHARs */
322 terminal_clear_EOL(el
, (int) Strlen(el
->el_display
[i
]));
324 terminal_overwrite(el
, "C\b", (size_t)2);
325 #endif /* DEBUG_REFRESH */
326 el
->el_display
[i
][0] = '\0';
329 el
->el_refresh
.r_oldcv
= el
->el_refresh
.r_newcv
; /* set for next time */
331 "\r\ncursor.h = %d, cursor.v = %d, cur.h = %d, cur.v = %d\r\n",
332 el
->el_refresh
.r_cursor
.h
, el
->el_refresh
.r_cursor
.v
,
334 terminal_move_to_line(el
, cur
.v
); /* go to where the cursor is */
335 terminal_move_to_char(el
, cur
.h
);
340 * used to go to last used screen line
343 re_goto_bottom(EditLine
*el
)
346 terminal_move_to_line(el
, el
->el_refresh
.r_oldcv
);
347 terminal__putc(el
, '\n');
348 re_clear_display(el
);
354 * insert num characters of s into d (in front of the character)
355 * at dat, maximum length of d is dlen
359 re_insert(EditLine
*el
__attribute__((__unused__
)),
360 Char
*d
, int dat
, int dlen
, Char
*s
, int num
)
366 if (num
> dlen
- dat
)
370 (__F
, "re_insert() starting: %d at %d max %d, d == \"%s\"\n",
371 num
, dat
, dlen
, ct_encode_string(d
)));
372 ELRE_DEBUG(1, (__F
, "s == \"%s\"\n", ct_encode_string(s
)));
374 /* open up the space for num chars */
380 d
[dlen
] = '\0'; /* just in case */
384 "re_insert() after insert: %d at %d max %d, d == \"%s\"\n",
385 num
, dat
, dlen
, ct_encode_string(d
)));
386 ELRE_DEBUG(1, (__F
, "s == \"%s\"\n", ct_encode_string(s
)));
388 /* copy the characters */
389 for (a
= d
+ dat
; (a
< d
+ dlen
) && (num
> 0); num
--)
393 /* ct_encode_string() uses a static buffer, so we can't conveniently
394 * encode both d & s here */
396 (__F
, "re_insert() after copy: %d at %d max %d, %s == \"%s\"\n",
397 num
, dat
, dlen
, d
, s
));
398 ELRE_DEBUG(1, (__F
, "s == \"%s\"\n", s
));
404 * delete num characters d at dat, maximum length of d is dlen
408 re_delete(EditLine
*el
__attribute__((__unused__
)),
409 Char
*d
, int dat
, int dlen
, int num
)
415 if (dat
+ num
>= dlen
) {
420 (__F
, "re_delete() starting: %d at %d max %d, d == \"%s\"\n",
421 num
, dat
, dlen
, ct_encode_string(d
)));
423 /* open up the space for num chars */
429 d
[dlen
] = '\0'; /* just in case */
432 (__F
, "re_delete() after delete: %d at %d max %d, d == \"%s\"\n",
433 num
, dat
, dlen
, ct_encode_string(d
)));
438 * Like strncpy without padding.
441 re__strncopy(Char
*a
, Char
*b
, size_t n
)
449 * Find the number of characters we need to clear till the end of line
450 * in order to make sure that we have cleared the previous contents of
451 * the line. fx and sx is the number of characters inserted or deleted
452 * in the first or second diff, diff is the difference between the
453 * number of characters between the new and old line.
456 re_clear_eol(EditLine
*el
, int fx
, int sx
, int diff
)
459 ELRE_DEBUG(1, (__F
, "re_clear_eol sx %d, fx %d, diff %d\n",
471 ELRE_DEBUG(1, (__F
, "re_clear_eol %d\n", diff
));
472 terminal_clear_EOL(el
, diff
);
475 /*****************************************************************
476 re_update_line() is based on finding the middle difference of each line
479 /old first difference
480 /beginning of line | /old last same /old EOL
482 old: eddie> Oh, my little gruntle-buggy is to me, as lurgid as
483 new: eddie> Oh, my little buggy says to me, as lurgid as
485 \beginning of line | \new last same \new end of line
486 \new first difference
488 all are character pointers for the sake of speed. Special cases for
489 no differences, as well as for end of line additions must be handled.
490 **************************************************************** */
492 /* Minimum at which doing an insert it "worth it". This should be about
493 * half the "cost" of going into insert mode, inserting a character, and
494 * going back out. This should really be calculated from the termcap
495 * data... For the moment, a good number for ANSI terminals.
497 #define MIN_END_KEEP 4
500 re_update_line(EditLine
*el
, Char
*old
, Char
*new, int i
)
503 Char
*ofd
, *ols
, *oe
, *nfd
, *nls
, *ne
;
504 Char
*osb
, *ose
, *nsb
, *nse
;
511 for (o
= old
, n
= new; *o
&& (*o
== *n
); o
++, n
++)
517 * Find the end of both old and new
522 * Remove any trailing blanks off of the end, being careful not to
523 * back up past the beginning.
536 /* remove blanks from end of new */
546 * if no diff, continue to next line of redraw
548 if (*ofd
== '\0' && *nfd
== '\0') {
549 ELRE_DEBUG(1, (__F
, "no difference.\r\n"));
553 * find last same pointer
555 while ((o
> ofd
) && (n
> nfd
) && (*--o
== *--n
))
561 * find same begining and same end
569 * case 1: insert: scan from nfd to nls looking for *ofd
572 for (c
= *ofd
, n
= nfd
; n
< nls
; n
++) {
575 p
< nls
&& o
< ols
&& *o
== *p
;
579 * if the new match is longer and it's worth
580 * keeping, then we take it
582 if (((nse
- nsb
) < (p
- n
)) &&
583 (2 * (p
- n
) > n
- nfd
)) {
593 * case 2: delete: scan from ofd to ols looking for *nfd
596 for (c
= *nfd
, o
= ofd
; o
< ols
; o
++) {
599 p
< ols
&& n
< nls
&& *p
== *n
;
603 * if the new match is longer and it's worth
604 * keeping, then we take it
606 if (((ose
- osb
) < (p
- o
)) &&
607 (2 * (p
- o
) > o
- ofd
)) {
617 * Pragmatics I: If old trailing whitespace or not enough characters to
618 * save to be worth it, then don't save the last same info.
620 if ((oe
- ols
) < MIN_END_KEEP
) {
625 * Pragmatics II: if the terminal isn't smart enough, make the data
626 * dumber so the smart update doesn't try anything fancy
630 * fx is the number of characters we need to insert/delete: in the
631 * beginning to bring the two same begins together
633 fx
= (int)((nsb
- nfd
) - (osb
- ofd
));
635 * sx is the number of characters we need to insert/delete: in the
636 * end to bring the two same last parts together
638 sx
= (int)((nls
- nse
) - (ols
- ose
));
640 if (!EL_CAN_INSERT
) {
651 if ((ols
- ofd
) < (nls
- nfd
)) {
656 if (!EL_CAN_DELETE
) {
667 if ((ols
- ofd
) > (nls
- nfd
)) {
673 * Pragmatics III: make sure the middle shifted pointers are correct if
674 * they don't point to anything (we may have moved ols or nls).
676 /* if the change isn't worth it, don't bother */
677 /* was: if (osb == ose) */
678 if ((ose
- osb
) < MIN_END_KEEP
) {
685 * Now that we are done with pragmatics we recompute fx, sx
687 fx
= (int)((nsb
- nfd
) - (osb
- ofd
));
688 sx
= (int)((nls
- nse
) - (ols
- ose
));
690 ELRE_DEBUG(1, (__F
, "fx %d, sx %d\n", fx
, sx
));
691 ELRE_DEBUG(1, (__F
, "ofd %d, osb %d, ose %d, ols %d, oe %d\n",
692 ofd
- old
, osb
- old
, ose
- old
, ols
- old
, oe
- old
));
693 ELRE_DEBUG(1, (__F
, "nfd %d, nsb %d, nse %d, nls %d, ne %d\n",
694 nfd
- new, nsb
- new, nse
- new, nls
- new, ne
- new));
696 "xxx-xxx:\"00000000001111111111222222222233333333334\"\r\n"));
698 "xxx-xxx:\"01234567890123456789012345678901234567890\"\r\n"));
700 re_printstr(el
, "old- oe", old
, oe
);
701 re_printstr(el
, "new- ne", new, ne
);
702 re_printstr(el
, "old-ofd", old
, ofd
);
703 re_printstr(el
, "new-nfd", new, nfd
);
704 re_printstr(el
, "ofd-osb", ofd
, osb
);
705 re_printstr(el
, "nfd-nsb", nfd
, nsb
);
706 re_printstr(el
, "osb-ose", osb
, ose
);
707 re_printstr(el
, "nsb-nse", nsb
, nse
);
708 re_printstr(el
, "ose-ols", ose
, ols
);
709 re_printstr(el
, "nse-nls", nse
, nls
);
710 re_printstr(el
, "ols- oe", ols
, oe
);
711 re_printstr(el
, "nls- ne", nls
, ne
);
712 #endif /* DEBUG_REFRESH */
715 * el_cursor.v to this line i MUST be in this routine so that if we
716 * don't have to change the line, we don't move to it. el_cursor.h to
719 terminal_move_to_line(el
, i
);
722 * at this point we have something like this:
724 * /old /ofd /osb /ose /ols /oe
725 * v.....................v v..................v v........v
726 * eddie> Oh, my fredded gruntle-buggy is to me, as foo var lurgid as
727 * eddie> Oh, my fredded quiux buggy is to me, as gruntle-lurgid as
728 * ^.....................^ ^..................^ ^........^
729 * \new \nfd \nsb \nse \nls \ne
731 * fx is the difference in length between the chars between nfd and
732 * nsb, and the chars between ofd and osb, and is thus the number of
733 * characters to delete if < 0 (new is shorter than old, as above),
734 * or insert (new is longer than short).
736 * sx is the same for the second differences.
740 * if we have a net insert on the first difference, AND inserting the
741 * net amount ((nsb-nfd) - (osb-ofd)) won't push the last useful
742 * character (which is ne if nls != ne, otherwise is nse) off the edge
743 * of the screen (el->el_terminal.t_size.h) else we do the deletes first
744 * so that we keep everything we need to.
748 * if the last same is the same like the end, there is no last same
749 * part, otherwise we want to keep the last same part set p to the
750 * last useful old character
752 p
= (ols
!= oe
) ? oe
: ose
;
755 * if (There is a diffence in the beginning) && (we need to insert
756 * characters) && (the number of characters to insert is less than
758 * We need to do an insert!
759 * else if (we need to delete characters)
760 * We need to delete characters!
762 * No insert or delete
764 if ((nsb
!= nfd
) && fx
> 0 &&
765 ((p
- old
) + fx
<= el
->el_terminal
.t_size
.h
)) {
767 (__F
, "first diff insert at %d...\r\n", nfd
- new));
769 * Move to the first char to insert, where the first diff is.
771 terminal_move_to_char(el
, (int)(nfd
- new));
773 * Check if we have stuff to keep at end
776 ELRE_DEBUG(1, (__F
, "with stuff to keep at end\r\n"));
778 * insert fx chars of new starting at nfd
781 ELRE_DEBUG(!EL_CAN_INSERT
, (__F
,
782 "ERROR: cannot insert in early first diff\n"));
783 terminal_insertwrite(el
, nfd
, fx
);
784 re_insert(el
, old
, (int)(ofd
- old
),
785 el
->el_terminal
.t_size
.h
, nfd
, fx
);
788 * write (nsb-nfd) - fx chars of new starting at
791 len
= (size_t) ((nsb
- nfd
) - fx
);
792 terminal_overwrite(el
, (nfd
+ fx
), len
);
793 re__strncopy(ofd
+ fx
, nfd
+ fx
, len
);
795 ELRE_DEBUG(1, (__F
, "without anything to save\r\n"));
796 len
= (size_t)(nsb
- nfd
);
797 terminal_overwrite(el
, nfd
, len
);
798 re__strncopy(ofd
, nfd
, len
);
806 (__F
, "first diff delete at %d...\r\n", ofd
- old
));
808 * move to the first char to delete where the first diff is
810 terminal_move_to_char(el
, (int)(ofd
- old
));
812 * Check if we have stuff to save
815 ELRE_DEBUG(1, (__F
, "with stuff to save at end\r\n"));
817 * fx is less than zero *always* here but we check
821 ELRE_DEBUG(!EL_CAN_DELETE
, (__F
,
822 "ERROR: cannot delete in first diff\n"));
823 terminal_deletechars(el
, -fx
);
824 re_delete(el
, old
, (int)(ofd
- old
),
825 el
->el_terminal
.t_size
.h
, -fx
);
828 * write (nsb-nfd) chars of new starting at nfd
830 len
= (size_t) (nsb
- nfd
);
831 terminal_overwrite(el
, nfd
, len
);
832 re__strncopy(ofd
, nfd
, len
);
836 "but with nothing left to save\r\n"));
838 * write (nsb-nfd) chars of new starting at nfd
840 terminal_overwrite(el
, nfd
, (size_t)(nsb
- nfd
));
841 re_clear_eol(el
, fx
, sx
,
842 (int)((oe
- old
) - (ne
- new)));
851 if (sx
< 0 && (ose
- old
) + fx
< el
->el_terminal
.t_size
.h
) {
853 "second diff delete at %d...\r\n", (ose
- old
) + fx
));
855 * Check if we have stuff to delete
858 * fx is the number of characters inserted (+) or deleted (-)
861 terminal_move_to_char(el
, (int)((ose
- old
) + fx
));
863 * Check if we have stuff to save
866 ELRE_DEBUG(1, (__F
, "with stuff to save at end\r\n"));
868 * Again a duplicate test.
871 ELRE_DEBUG(!EL_CAN_DELETE
, (__F
,
872 "ERROR: cannot delete in second diff\n"));
873 terminal_deletechars(el
, -sx
);
876 * write (nls-nse) chars of new starting at nse
878 terminal_overwrite(el
, nse
, (size_t)(nls
- nse
));
881 "but with nothing left to save\r\n"));
882 terminal_overwrite(el
, nse
, (size_t)(nls
- nse
));
883 re_clear_eol(el
, fx
, sx
,
884 (int)((oe
- old
) - (ne
- new)));
888 * if we have a first insert AND WE HAVEN'T ALREADY DONE IT...
890 if ((nsb
!= nfd
) && (osb
- ofd
) <= (nsb
- nfd
) && (fx
== 0)) {
891 ELRE_DEBUG(1, (__F
, "late first diff insert at %d...\r\n",
894 terminal_move_to_char(el
, (int)(nfd
- new));
896 * Check if we have stuff to keep at the end
899 ELRE_DEBUG(1, (__F
, "with stuff to keep at end\r\n"));
901 * We have to recalculate fx here because we set it
902 * to zero above as a flag saying that we hadn't done
903 * an early first insert.
905 fx
= (int)((nsb
- nfd
) - (osb
- ofd
));
908 * insert fx chars of new starting at nfd
910 ELRE_DEBUG(!EL_CAN_INSERT
, (__F
,
911 "ERROR: cannot insert in late first diff\n"));
912 terminal_insertwrite(el
, nfd
, fx
);
913 re_insert(el
, old
, (int)(ofd
- old
),
914 el
->el_terminal
.t_size
.h
, nfd
, fx
);
917 * write (nsb-nfd) - fx chars of new starting at
920 len
= (size_t) ((nsb
- nfd
) - fx
);
921 terminal_overwrite(el
, (nfd
+ fx
), len
);
922 re__strncopy(ofd
+ fx
, nfd
+ fx
, len
);
924 ELRE_DEBUG(1, (__F
, "without anything to save\r\n"));
925 len
= (size_t) (nsb
- nfd
);
926 terminal_overwrite(el
, nfd
, len
);
927 re__strncopy(ofd
, nfd
, len
);
931 * line is now NEW up to nse
935 "second diff insert at %d...\r\n", (int)(nse
- new)));
936 terminal_move_to_char(el
, (int)(nse
- new));
938 ELRE_DEBUG(1, (__F
, "with stuff to keep at end\r\n"));
940 /* insert sx chars of new starting at nse */
941 ELRE_DEBUG(!EL_CAN_INSERT
, (__F
,
942 "ERROR: cannot insert in second diff\n"));
943 terminal_insertwrite(el
, nse
, sx
);
946 * write (nls-nse) - sx chars of new starting at
949 terminal_overwrite(el
, (nse
+ sx
),
950 (size_t)((nls
- nse
) - sx
));
952 ELRE_DEBUG(1, (__F
, "without anything to save\r\n"));
953 terminal_overwrite(el
, nse
, (size_t)(nls
- nse
));
956 * No need to do a clear-to-end here because we were
957 * doing a second insert, so we will have over
958 * written all of the old string.
962 ELRE_DEBUG(1, (__F
, "done.\r\n"));
966 /* re__copy_and_pad():
967 * Copy string and pad with spaces
970 re__copy_and_pad(Char
*dst
, const Char
*src
, size_t width
)
974 for (i
= 0; i
< width
; i
++) {
980 for (; i
< width
; i
++)
987 /* re_refresh_cursor():
988 * Move to the new cursor position
991 re_refresh_cursor(EditLine
*el
)
996 if (el
->el_line
.cursor
>= el
->el_line
.lastchar
) {
997 if (el
->el_map
.current
== el
->el_map
.alt
998 && el
->el_line
.lastchar
!= el
->el_line
.buffer
)
999 el
->el_line
.cursor
= el
->el_line
.lastchar
- 1;
1001 el
->el_line
.cursor
= el
->el_line
.lastchar
;
1004 /* first we must find where the cursor is... */
1005 h
= el
->el_prompt
.p_pos
.h
;
1006 v
= el
->el_prompt
.p_pos
.v
;
1007 th
= el
->el_terminal
.t_size
.h
; /* optimize for speed */
1009 /* do input buffer to el->el_line.cursor */
1010 for (cp
= el
->el_line
.buffer
; cp
< el
->el_line
.cursor
; cp
++) {
1011 switch (ct_chr_class(*cp
)) {
1012 case CHTYPE_NL
: /* handle newline in data part too */
1016 case CHTYPE_TAB
: /* if a tab, to next tab stop */
1022 if (w
> 1 && h
+ w
> th
) { /* won't fit on line */
1026 h
+= ct_visual_width(*cp
);
1030 if (h
>= th
) { /* check, extra long tabs picked up here also */
1035 /* if we have a next character, and it's a doublewidth one, we need to
1036 * check whether we need to linebreak for it to fit */
1037 if (cp
< el
->el_line
.lastchar
&& (w
= Width(*cp
)) > 1)
1044 terminal_move_to_line(el
, v
);
1045 terminal_move_to_char(el
, h
);
1046 terminal__flush(el
);
1051 * Add a character fast.
1054 re_fastputc(EditLine
*el
, Int c
)
1056 int w
= Width((Char
)c
);
1057 while (w
> 1 && el
->el_cursor
.h
+ w
> el
->el_terminal
.t_size
.h
)
1058 re_fastputc(el
, ' ');
1060 terminal__putc(el
, c
);
1061 el
->el_display
[el
->el_cursor
.v
][el
->el_cursor
.h
++] = c
;
1063 el
->el_display
[el
->el_cursor
.v
][el
->el_cursor
.h
++]
1066 if (el
->el_cursor
.h
>= el
->el_terminal
.t_size
.h
) {
1067 /* if we must overflow */
1068 el
->el_cursor
.h
= 0;
1071 * If we would overflow (input is longer than terminal size),
1072 * emulate scroll by dropping first line and shuffling the rest.
1073 * We do this via pointer shuffling - it's safe in this case
1074 * and we avoid memcpy().
1076 if (el
->el_cursor
.v
+ 1 >= el
->el_terminal
.t_size
.v
) {
1077 int i
, lins
= el
->el_terminal
.t_size
.v
;
1078 Char
*firstline
= el
->el_display
[0];
1080 for(i
= 1; i
< lins
; i
++)
1081 el
->el_display
[i
- 1] = el
->el_display
[i
];
1083 re__copy_and_pad(firstline
, STR(""), (size_t)0);
1084 el
->el_display
[i
- 1] = firstline
;
1087 el
->el_refresh
.r_oldcv
++;
1089 if (EL_HAS_AUTO_MARGINS
) {
1090 if (EL_HAS_MAGIC_MARGINS
) {
1091 terminal__putc(el
, ' ');
1092 terminal__putc(el
, '\b');
1095 terminal__putc(el
, '\r');
1096 terminal__putc(el
, '\n');
1103 * we added just one char, handle it fast.
1104 * Assumes that screen cursor == real cursor
1107 re_fastaddc(EditLine
*el
)
1112 c
= el
->el_line
.cursor
[-1];
1114 if (c
== '\t' || el
->el_line
.cursor
!= el
->el_line
.lastchar
) {
1115 re_refresh(el
); /* too hard to handle */
1118 rhdiff
= el
->el_terminal
.t_size
.h
- el
->el_cursor
.h
-
1119 el
->el_rprompt
.p_pos
.h
;
1120 if (el
->el_rprompt
.p_pos
.h
&& rhdiff
< 3) {
1121 re_refresh(el
); /* clear out rprompt if less than 1 char gap */
1123 } /* else (only do at end of line, no TAB) */
1124 switch (ct_chr_class(c
)) {
1125 case CHTYPE_TAB
: /* already handled, should never happen here */
1131 case CHTYPE_ASCIICTL
:
1132 case CHTYPE_NONPRINT
: {
1133 Char visbuf
[VISUAL_WIDTH_MAX
];
1135 ct_visual_char(visbuf
, VISUAL_WIDTH_MAX
, (Char
)c
);
1136 for (i
= 0; n
-- > 0; ++i
)
1137 re_fastputc(el
, visbuf
[i
]);
1141 terminal__flush(el
);
1145 /* re_clear_display():
1146 * clear the screen buffers so that new new prompt starts fresh.
1149 re_clear_display(EditLine
*el
)
1153 el
->el_cursor
.v
= 0;
1154 el
->el_cursor
.h
= 0;
1155 for (i
= 0; i
< el
->el_terminal
.t_size
.v
; i
++)
1156 el
->el_display
[i
][0] = '\0';
1157 el
->el_refresh
.r_oldcv
= 0;
1161 /* re_clear_lines():
1162 * Make sure all lines are *really* blank
1165 re_clear_lines(EditLine
*el
)
1170 for (i
= el
->el_refresh
.r_oldcv
; i
>= 0; i
--) {
1171 /* for each line on the screen */
1172 terminal_move_to_line(el
, i
);
1173 terminal_move_to_char(el
, 0);
1174 terminal_clear_EOL(el
, el
->el_terminal
.t_size
.h
);
1177 terminal_move_to_line(el
, el
->el_refresh
.r_oldcv
);
1178 /* go to last line */
1179 terminal__putc(el
, '\r'); /* go to BOL */
1180 terminal__putc(el
, '\n'); /* go to new line */