2 * Copyright (c) 1993, 1994
3 * The Regents of the University of California. All rights reserved.
4 * Copyright (c) 1992, 1993, 1994, 1995, 1996
5 * Keith Bostic. All rights reserved.
7 * See the LICENSE file for redistribution information.
13 static const char sccsid
[] = "$Id: vs_msg.c,v 10.85 2001/07/29 19:07:31 skimo Exp $ (Berkeley) $Date: 2001/07/29 19:07:31 $";
16 #include <sys/types.h>
17 #include <sys/queue.h>
20 #include <bitstring.h>
27 #include "../common/common.h"
31 SCROLL_W
, /* User wait. */
32 SCROLL_W_EX
, /* User wait, or enter : to continue. */
33 SCROLL_W_QUIT
/* User wait, or enter q to quit. */
35 * SCROLL_W_QUIT has another semantic
36 * -- only wait if the screen is full
40 static void vs_divider
__P((SCR
*));
41 static void vs_msgsave
__P((SCR
*, mtype_t
, char *, size_t));
42 static void vs_output
__P((SCR
*, mtype_t
, const char *, int));
43 static void vs_scroll
__P((SCR
*, int *, sw_t
));
44 static void vs_wait
__P((SCR
*, int *, sw_t
));
48 * Display, update or clear a busy message.
50 * This routine is the default editor interface for vi busy messages. It
51 * implements a standard strategy of stealing lines from the bottom of the
52 * vi text screen. Screens using an alternate method of displaying busy
53 * messages, e.g. X11 clock icons, should set their scr_busy function to the
54 * correct function before calling the main editor routine.
56 * PUBLIC: void vs_busy __P((SCR *, const char *, busy_t));
59 vs_busy(SCR
*sp
, const char *msg
, busy_t btype
)
63 static const char flagc
[] = "|/-\\";
68 /* Ex doesn't display busy messages. */
69 if (F_ISSET(sp
, SC_EX
| SC_SCR_EXWROTE
))
76 * Most of this routine is to deal with the screen sharing real estate
77 * between the normal edit messages and the busy messages. Logically,
78 * all that's needed is something that puts up a message, periodically
79 * updates it, and then goes away.
84 if (vip
->totalcount
!= 0 || vip
->busy_ref
!= 1)
87 /* Initialize state for updates. */
89 (void)gettimeofday(&vip
->busy_tv
, NULL
);
91 /* Save the current cursor. */
92 (void)gp
->scr_cursor(sp
, &vip
->busy_oldy
, &vip
->busy_oldx
);
94 /* Display the busy message. */
95 p
= msg_cat(sp
, msg
, &len
);
96 (void)gp
->scr_move(sp
, LASTLINE(sp
), 0);
97 (void)gp
->scr_addstr(sp
, p
, len
);
98 (void)gp
->scr_cursor(sp
, ¬used
, &vip
->busy_fx
);
99 (void)gp
->scr_clrtoeol(sp
);
100 (void)gp
->scr_move(sp
, LASTLINE(sp
), vip
->busy_fx
);
103 if (vip
->busy_ref
== 0)
108 * If the line isn't in use for another purpose, clear it.
109 * Always return to the original position.
111 if (vip
->totalcount
== 0 && vip
->busy_ref
== 0) {
112 (void)gp
->scr_move(sp
, LASTLINE(sp
), 0);
113 (void)gp
->scr_clrtoeol(sp
);
115 (void)gp
->scr_move(sp
, vip
->busy_oldy
, vip
->busy_oldx
);
118 if (vip
->totalcount
!= 0 || vip
->busy_ref
== 0)
121 /* Update no more than every 1/8 of a second. */
122 (void)gettimeofday(&tv
, NULL
);
123 if (((tv
.tv_sec
- vip
->busy_tv
.tv_sec
) * 1000000 +
124 (tv
.tv_usec
- vip
->busy_tv
.tv_usec
)) < 125000)
128 /* Display the update. */
129 if (vip
->busy_ch
== sizeof(flagc
) - 1)
131 (void)gp
->scr_move(sp
, LASTLINE(sp
), vip
->busy_fx
);
132 (void)gp
->scr_addstr(sp
, flagc
+ vip
->busy_ch
++, 1);
133 (void)gp
->scr_move(sp
, LASTLINE(sp
), vip
->busy_fx
);
136 (void)gp
->scr_refresh(sp
, 0);
141 * Home the cursor to the bottom row, left-most column.
143 * PUBLIC: void vs_home __P((SCR *));
148 (void)sp
->gp
->scr_move(sp
, LASTLINE(sp
), 0);
149 (void)sp
->gp
->scr_refresh(sp
, 0);
156 * PUBLIC: void vs_update __P((SCR *, const char *, const CHAR_T *));
159 vs_update(SCR
*sp
, const char *m1
, const CHAR_T
*m2
)
162 size_t len
, mlen
, oldx
, oldy
;
169 * This routine displays a message on the bottom line of the screen,
170 * without updating any of the command structures that would keep it
171 * there for any period of time, i.e. it is overwritten immediately.
173 * It's used by the ex read and ! commands when the user's command is
174 * expanded, and by the ex substitution confirmation prompt.
176 if (F_ISSET(sp
, SC_SCR_EXWROTE
)) {
178 INT2CHAR(sp
, m2
, STRLEN(m2
) + 1, np
, nlen
);
180 "%s\n", m1
== NULL
? "" : m1
, m2
== NULL
? "" : np
);
185 * Save the cursor position, the substitute-with-confirmation code
186 * will have already set it correctly.
188 (void)gp
->scr_cursor(sp
, &oldy
, &oldx
);
190 /* Clear the bottom line. */
191 (void)gp
->scr_move(sp
, LASTLINE(sp
), 0);
192 (void)gp
->scr_clrtoeol(sp
);
196 * Don't let long file names screw up the screen.
199 mlen
= len
= strlen(m1
);
200 if (len
> sp
->cols
- 2)
201 mlen
= len
= sp
->cols
- 2;
202 (void)gp
->scr_addstr(sp
, m1
, mlen
);
207 if (len
+ mlen
> sp
->cols
- 2)
208 mlen
= (sp
->cols
- 2) - len
;
209 (void)gp
->scr_waddstr(sp
, m2
, mlen
);
212 (void)gp
->scr_move(sp
, oldy
, oldx
);
213 (void)gp
->scr_refresh(sp
, 0);
218 * Display ex output or error messages for the screen.
220 * This routine is the default editor interface for all ex output, and all ex
221 * and vi error/informational messages. It implements the standard strategy
222 * of stealing lines from the bottom of the vi text screen. Screens using an
223 * alternate method of displaying messages, e.g. dialog boxes, should set their
224 * scr_msg function to the correct function before calling the editor.
226 * PUBLIC: void vs_msg __P((SCR *, mtype_t, char *, size_t));
229 vs_msg(SCR
*sp
, mtype_t mtype
, char *line
, size_t len
)
233 size_t maxcols
, oldx
, oldy
, padding
;
234 const char *e
, *s
, *t
;
240 * Ring the bell if it's scheduled.
243 * Shouldn't we save this, too?
245 if (F_ISSET(sp
, SC_TINPUT_INFO
) || F_ISSET(gp
, G_BELLSCHED
))
246 if (F_ISSET(sp
, SC_SCR_VI
)) {
247 F_CLR(gp
, G_BELLSCHED
);
248 (void)gp
->scr_bell(sp
);
250 F_SET(gp
, G_BELLSCHED
);
253 * If vi is using the error line for text input, there's no screen
254 * real-estate for the error message. Nothing to do without some
255 * information as to how important the error message is.
257 if (F_ISSET(sp
, SC_TINPUT_INFO
))
261 * Ex or ex controlled screen output.
263 * If output happens during startup, e.g., a .exrc file, we may be
264 * in ex mode but haven't initialized the screen. Initialize here,
265 * and in this case, stay in ex mode.
267 * If the SC_SCR_EXWROTE bit is set, then we're switching back and
268 * forth between ex and vi, but the screen is trashed and we have
269 * to respect that. Switch to ex mode long enough to put out the
272 * If the SC_EX_WAIT_NO bit is set, turn it off -- we're writing to
273 * the screen, so previous opinions are ignored.
275 if (F_ISSET(sp
, SC_EX
| SC_SCR_EXWROTE
)) {
276 if (!F_ISSET(sp
, SC_SCR_EX
))
277 if (F_ISSET(sp
, SC_SCR_EXWROTE
)) {
278 if (sp
->gp
->scr_screen(sp
, SC_EX
))
285 (void)gp
->scr_attr(sp
, SA_INVERSE
, 1);
286 (void)printf("%.*s", (int)len
, line
);
288 (void)gp
->scr_attr(sp
, SA_INVERSE
, 0);
289 (void)fflush(stdout
);
291 F_CLR(sp
, SC_EX_WAIT_NO
);
293 if (!F_ISSET(sp
, SC_SCR_EX
))
294 (void)sp
->gp
->scr_screen(sp
, SC_VI
);
298 /* If the vi screen isn't ready, save the message. */
299 if (!F_ISSET(sp
, SC_SCR_VI
)) {
300 (void)vs_msgsave(sp
, mtype
, line
, len
);
304 /* Save the cursor position. */
305 (void)gp
->scr_cursor(sp
, &oldy
, &oldx
);
307 /* If it's an ex output message, just write it out. */
308 if (mtype
== M_NONE
) {
309 vs_output(sp
, mtype
, line
, len
);
314 * If it's a vi message, strip the trailing <newline> so we can
315 * try and paste messages together.
317 if (line
[len
- 1] == '\n')
321 * If a message won't fit on a single line, try to split on a <blank>.
322 * If a subsequent message fits on the same line, write a separator
323 * and output it. Otherwise, put out a newline.
325 * Need up to two padding characters normally; a semi-colon and a
326 * separating space. If only a single line on the screen, add some
327 * more for the trailing continuation message.
330 * Assume that periods and semi-colons take up a single column on the
334 * There are almost certainly pathological cases that will break this
338 (void)msg_cmsg(sp
, CMSG_CONT_S
, &padding
);
343 maxcols
= sp
->cols
- 1;
344 if (vip
->lcontinue
!= 0)
345 if (len
+ vip
->lcontinue
+ padding
> maxcols
)
346 vs_output(sp
, vip
->mtype
, ".\n", 2);
348 vs_output(sp
, vip
->mtype
, ";", 1);
349 vs_output(sp
, M_NONE
, " ", 1);
352 for (s
= line
;; s
= t
) {
353 for (; len
> 0 && isblank(*s
); --len
, ++s
);
356 if (len
+ vip
->lcontinue
> maxcols
) {
357 for (e
= s
+ (maxcols
- vip
->lcontinue
);
358 e
> s
&& !isblank(*e
); --e
);
360 e
= t
= s
+ (maxcols
- vip
->lcontinue
);
362 for (t
= e
; isblank(e
[-1]); --e
);
367 * If the message ends in a period, discard it, we want to
368 * gang messages where possible.
371 if (len
== 0 && (e
- s
) > 1 && s
[(e
- s
) - 1] == '.')
373 vs_output(sp
, mtype
, s
, e
- s
);
376 vs_output(sp
, M_NONE
, "\n", 1);
382 ret
: (void)gp
->scr_move(sp
, oldy
, oldx
);
383 (void)gp
->scr_refresh(sp
, 0);
388 * Output the text to the screen.
391 vs_output(SCR
*sp
, mtype_t mtype
, const char *line
, int llen
)
396 size_t chlen
, notused
;
397 int ch
, len
, rlen
, tlen
;
399 char *cbp
, *ecbp
, cbuf
[128];
403 for (p
= line
, rlen
= llen
; llen
> 0;) {
404 /* Get the next physical line. */
405 if ((p
= memchr(line
, '\n', llen
)) == NULL
)
411 * The max is sp->cols characters, and we may have already
412 * written part of the line.
414 if (len
+ vip
->lcontinue
> sp
->cols
)
415 len
= sp
->cols
- vip
->lcontinue
;
418 * If the first line output, do nothing. If the second line
419 * output, draw the divider line. If drew a full screen, we
420 * remove the divider line. If it's a continuation line, move
421 * to the continuation point, else, move the screen up.
423 if (vip
->lcontinue
== 0) {
424 if (!IS_ONELINE(sp
)) {
425 if (vip
->totalcount
== 1) {
426 (void)gp
->scr_move(sp
,
427 LASTLINE(sp
) - 1, 0);
428 (void)gp
->scr_clrtoeol(sp
);
429 (void)vs_divider(sp
);
430 F_SET(vip
, VIP_DIVIDER
);
434 if (vip
->totalcount
== sp
->t_maxrows
&&
435 F_ISSET(vip
, VIP_DIVIDER
)) {
438 F_CLR(vip
, VIP_DIVIDER
);
441 if (vip
->totalcount
!= 0)
442 vs_scroll(sp
, NULL
, SCROLL_W_QUIT
);
444 (void)gp
->scr_move(sp
, LASTLINE(sp
), 0);
451 (void)gp
->scr_move(sp
, LASTLINE(sp
), vip
->lcontinue
);
453 /* Error messages are in inverse video. */
455 (void)gp
->scr_attr(sp
, SA_INVERSE
, 1);
457 /* Display the line, doing character translation. */
460 (void)gp->scr_addstr(sp, cbuf, cbp - cbuf); \
463 ecbp
= (cbp
= cbuf
) + sizeof(cbuf
) - 1;
464 for (t
= line
, tlen
= len
; tlen
--; ++t
) {
467 * Replace tabs with spaces, there are places in
468 * ex that do column calculations without looking
469 * at <tabs> -- and all routines that care about
470 * <tabs> do their own expansions. This catches
471 * <tabs> in things like tag search strings.
475 chlen
= KEY_LEN(sp
, ch
);
476 if (cbp
+ chlen
>= ecbp
)
478 for (kp
= KEY_NAME(sp
, ch
); chlen
--;)
484 (void)gp
->scr_attr(sp
, SA_INVERSE
, 0);
486 /* Clear the rest of the line. */
487 (void)gp
->scr_clrtoeol(sp
);
489 /* If we loop, it's a new line. */
492 /* Reset for the next line. */
501 /* Set up next continuation line. */
503 gp
->scr_cursor(sp
, ¬used
, &vip
->lcontinue
);
508 * Deal with ex message output.
510 * This routine is called when exiting a colon command to resolve any ex
511 * output that may have occurred.
513 * PUBLIC: int vs_ex_resolve __P((SCR *, int *));
516 vs_ex_resolve(SCR
*sp
, int *continuep
)
527 /* If we ran any ex command, we can't trust the cursor position. */
528 F_SET(vip
, VIP_CUR_INVALID
);
530 /* Terminate any partially written message. */
531 if (vip
->lcontinue
!= 0) {
532 vs_output(sp
, vip
->mtype
, ".", 1);
539 * If we switched out of the vi screen into ex, switch back while we
540 * figure out what to do with the screen and potentially get another
541 * command to execute.
543 * If we didn't switch into ex, we're not required to wait, and less
544 * than 2 lines of output, we can continue without waiting for the
547 * Note, all other code paths require waiting, so we leave the report
548 * of modified lines until later, so that we won't wait for no other
549 * reason than a threshold number of lines were modified. This means
550 * we display cumulative line modification reports for groups of ex
551 * commands. That seems right to me (well, at least not wrong).
553 if (F_ISSET(sp
, SC_SCR_EXWROTE
)) {
554 if (sp
->gp
->scr_screen(sp
, SC_VI
))
557 if (!F_ISSET(sp
, SC_EX_WAIT_YES
) && vip
->totalcount
< 2) {
558 F_CLR(sp
, SC_EX_WAIT_NO
);
562 /* Clear the required wait flag, it's no longer needed. */
563 F_CLR(sp
, SC_EX_WAIT_YES
);
566 * Wait, unless explicitly told not to wait or the user interrupted
567 * the command. If the user is leaving the screen, for any reason,
568 * they can't continue with further ex commands.
570 if (!F_ISSET(sp
, SC_EX_WAIT_NO
) && !INTERRUPTED(sp
)) {
571 wtype
= F_ISSET(sp
, SC_EXIT
| SC_EXIT_FORCE
|
572 SC_FSWITCH
| SC_SSWITCH
) ? SCROLL_W
: SCROLL_W_EX
;
573 if (F_ISSET(sp
, SC_SCR_EXWROTE
))
574 vs_wait(sp
, continuep
, wtype
);
576 vs_scroll(sp
, continuep
, wtype
);
581 /* If ex wrote on the screen, refresh the screen image. */
582 if (F_ISSET(sp
, SC_SCR_EXWROTE
))
583 F_SET(vip
, VIP_N_EX_PAINT
);
586 * If we're not the bottom of the split screen stack, the screen
587 * image itself is wrong, so redraw everything.
589 if (sp
->q
.cqe_next
!= (void *)&sp
->wp
->scrq
)
590 F_SET(sp
, SC_SCR_REDRAW
);
592 /* If ex changed the underlying file, the map itself is wrong. */
593 if (F_ISSET(vip
, VIP_N_EX_REDRAW
))
594 F_SET(sp
, SC_SCR_REFORMAT
);
596 /* Ex may have switched out of the alternate screen, return. */
597 (void)gp
->scr_attr(sp
, SA_ALTERNATE
, 1);
600 * Whew. We're finally back home, after what feels like years.
603 F_CLR(sp
, SC_SCR_EXWROTE
| SC_EX_WAIT_NO
);
606 * We may need to repaint some of the screen, e.g.:
611 * gives us a combination of some lines that are "wrong", and a need
612 * for a full refresh.
614 if (vip
->totalcount
> 1) {
615 /* Set up the redraw of the overwritten lines. */
616 ev
.e_event
= E_REPAINT
;
617 ev
.e_flno
= vip
->totalcount
>=
618 sp
->rows
? 1 : sp
->rows
- vip
->totalcount
;
619 ev
.e_tlno
= sp
->rows
;
621 /* Reset the count of overwriting lines. */
622 vip
->linecount
= vip
->lcontinue
= vip
->totalcount
= 0;
625 (void)v_erepaint(sp
, &ev
);
627 /* Reset the count of overwriting lines. */
628 vip
->linecount
= vip
->lcontinue
= vip
->totalcount
= 0;
635 * Deal with message output.
637 * PUBLIC: int vs_resolve __P((SCR *, SCR *, int));
640 vs_resolve(SCR
*sp
, SCR
*csp
, int forcewait
)
651 * Vs_resolve is called from the main vi loop and the refresh function
652 * to periodically ensure that the user has seen any messages that have
653 * been displayed and that any status lines are correct. The sp screen
654 * is the screen we're checking, usually the current screen. When it's
655 * not, csp is the current screen, used for final cursor positioning.
663 /* Save the cursor position. */
664 (void)gp
->scr_cursor(csp
, &oldy
, &oldx
);
666 /* Ring the bell if it's scheduled. */
667 if (F_ISSET(gp
, G_BELLSCHED
)) {
668 F_CLR(gp
, G_BELLSCHED
);
669 (void)gp
->scr_bell(sp
);
672 /* Display new file status line. */
673 if (F_ISSET(sp
, SC_STATUS
)) {
674 F_CLR(sp
, SC_STATUS
);
675 msgq_status(sp
, sp
->lno
, MSTAT_TRUNCATE
);
678 /* Report on line modifications. */
682 * Flush any saved messages. If the screen isn't ready, refresh
683 * it. (A side-effect of screen refresh is that we can display
684 * messages.) Once this is done, don't trust the cursor. That
685 * extra refresh screwed the pooch.
687 if (gp
->msgq
.lh_first
!= NULL
) {
688 if (!F_ISSET(sp
, SC_SCR_VI
) && vs_refresh(sp
, 1))
690 while ((mp
= gp
->msgq
.lh_first
) != NULL
) {
691 wp
->scr_msg(sp
, mp
->mtype
, mp
->buf
, mp
->len
);
696 F_SET(vip
, VIP_CUR_INVALID
);
699 switch (vip
->totalcount
) {
705 * If we're switching screens, we have to wait for messages,
706 * regardless. If we don't wait, skip updating the modeline.
709 vs_scroll(sp
, NULL
, SCROLL_W
);
711 F_SET(vip
, VIP_S_MODELINE
);
717 * If >1 message line in use, prompt the user to continue and
718 * repaint overwritten lines.
720 vs_scroll(sp
, NULL
, SCROLL_W
);
722 ev
.e_event
= E_REPAINT
;
723 ev
.e_flno
= vip
->totalcount
>=
724 sp
->rows
? 1 : sp
->rows
- vip
->totalcount
;
725 ev
.e_tlno
= sp
->rows
;
731 /* Reset the count of overwriting lines. */
732 vip
->linecount
= vip
->lcontinue
= vip
->totalcount
= 0;
736 (void)v_erepaint(sp
, &ev
);
738 /* Restore the cursor position. */
739 (void)gp
->scr_move(csp
, oldy
, oldx
);
746 * Scroll the screen for output.
749 vs_scroll(SCR
*sp
, int *continuep
, sw_t wtype
)
756 if (!IS_ONELINE(sp
)) {
758 * Scroll the screen. Instead of scrolling the entire screen,
759 * delete the line above the first line output so preserve the
760 * maximum amount of the screen.
762 (void)gp
->scr_move(sp
, vip
->totalcount
<
763 sp
->rows
? LASTLINE(sp
) - vip
->totalcount
: 0, 0);
764 (void)gp
->scr_deleteln(sp
);
766 /* If there are screens below us, push them back into place. */
767 if (sp
->q
.cqe_next
!= (void *)&sp
->wp
->scrq
) {
768 (void)gp
->scr_move(sp
, LASTLINE(sp
), 0);
769 (void)gp
->scr_insertln(sp
);
772 if (wtype
== SCROLL_W_QUIT
&& vip
->linecount
< sp
->t_maxrows
)
774 vs_wait(sp
, continuep
, wtype
);
779 * Prompt the user to continue.
782 vs_wait(SCR
*sp
, int *continuep
, sw_t wtype
)
793 (void)gp
->scr_move(sp
, LASTLINE(sp
), 0);
795 p
= msg_cmsg(sp
, CMSG_CONT_S
, &len
);
799 p
= msg_cmsg(sp
, CMSG_CONT_Q
, &len
);
802 p
= msg_cmsg(sp
, CMSG_CONT_EX
, &len
);
805 p
= msg_cmsg(sp
, CMSG_CONT
, &len
);
811 (void)gp
->scr_addstr(sp
, p
, len
);
816 (void)gp
->scr_clrtoeol(sp
);
817 (void)gp
->scr_refresh(sp
, 0);
819 /* Get a single character from the terminal. */
820 if (continuep
!= NULL
)
823 if (v_event_get(sp
, &ev
, 0, 0))
825 if (ev
.e_event
== E_CHARACTER
)
827 if (ev
.e_event
== E_INTERRUPT
) {
829 F_SET(gp
, G_INTERRUPTED
);
832 (void)gp
->scr_bell(sp
);
836 if (ev
.e_c
== CH_QUIT
)
837 F_SET(gp
, G_INTERRUPTED
);
840 if (ev
.e_c
== ':' && continuep
!= NULL
)
850 * Draw a dividing line between the screen and the output.
858 #define DIVIDESTR "+=+=+=+=+=+=+=+"
860 sizeof(DIVIDESTR
) - 1 > sp
->cols
? sp
->cols
: sizeof(DIVIDESTR
) - 1;
862 (void)gp
->scr_attr(sp
, SA_INVERSE
, 1);
863 (void)gp
->scr_addstr(sp
, DIVIDESTR
, len
);
864 (void)gp
->scr_attr(sp
, SA_INVERSE
, 0);
869 * Save a message for later display.
872 vs_msgsave(SCR
*sp
, mtype_t mt
, char *p
, size_t len
)
878 * We have to handle messages before we have any place to put them.
879 * If there's no screen support yet, allocate a msg structure, copy
880 * in the message, and queue it on the global structure. If we can't
881 * allocate memory here, we're genuinely screwed, dump the message
882 * to stderr in the (probably) vain hope that someone will see it.
884 CALLOC_GOTO(sp
, mp_n
, MSGS
*, 1, sizeof(MSGS
));
885 MALLOC_GOTO(sp
, mp_n
->buf
, char *, len
);
887 memmove(mp_n
->buf
, p
, len
);
892 if ((mp_c
= gp
->msgq
.lh_first
) == NULL
) {
893 LIST_INSERT_HEAD(&gp
->msgq
, mp_n
, q
);
895 for (; mp_c
->q
.le_next
!= NULL
; mp_c
= mp_c
->q
.le_next
);
896 LIST_INSERT_AFTER(mp_c
, mp_n
, q
);
903 (void)fprintf(stderr
, "%.*s\n", (int)len
, p
);