![[BACK]](/icons/back.gif){kind=icon}
Return to message.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / vim|
Return to message.c CVS log | Up to [local] / src / usr.bin / vim |
1.1 downsj 1: /* $OpenBSD$ */
2: /* vi:set ts=4 sw=4:
3: *
4: * VIM - Vi IMproved by Bram Moolenaar
5: *
6: * Do ":help uganda" in Vim to read copying and usage conditions.
7: * Do ":help credits" in Vim to see a list of people who contributed.
8: */
9:
10: /*
11: * message.c: functions for displaying messages on the command line
12: */
13:
14: #include "vim.h"
15: #include "globals.h"
16: #define MESSAGE /* don't include prototype for smsg() */
17: #include "proto.h"
18: #include "option.h"
19:
20: static void msg_screen_outchar __ARGS((int c));
21: static int msg_check_screen __ARGS((void));
22:
23: static int lines_left = -1; /* lines left for listing */
24:
25: /*
26: * msg(s) - displays the string 's' on the status line
27: * When terminal not initialized (yet) fprintf(stderr,..) is used.
28: * return TRUE if wait_return not called
29: */
30: int
31: msg(s)
32: char_u *s;
33: {
34: msg_start();
35: if (msg_highlight)
36: start_highlight();
37: msg_outtrans(s);
38: if (msg_highlight)
39: {
40: stop_highlight();
41: msg_highlight = FALSE; /* clear for next call */
42: }
43: msg_clr_eos();
44: return msg_end();
45: }
46:
47: /*
48: * automatic prototype generation does not understand this function
49: */
50: #ifndef PROTO
51: int smsg __ARGS((char_u *, long, long, long,
52: long, long, long, long, long, long, long));
53:
54: /* VARARGS */
55: int
56: smsg(s, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
57: char_u *s;
58: long a1, a2, a3, a4, a5, a6, a7, a8, a9, a10;
59: {
60: sprintf((char *)IObuff, (char *)s, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
61: return msg(IObuff);
62: }
63: #endif
64:
65: /*
66: * emsg() - display an error message
67: *
68: * Rings the bell, if appropriate, and calls message() to do the real work
69: * When terminal not initialized (yet) fprintf(stderr,..) is used.
70: *
71: * return TRUE if wait_return not called
72: */
73: int
74: emsg(s)
75: char_u *s;
76: {
77: char_u *Buf;
78: #ifdef SLEEP_IN_EMSG
79: int retval;
80: #endif
81: static int last_lnum = 0;
82: static char_u *last_sourcing_name = NULL;
83:
84: if (emsg_off) /* no error messages at the moment */
85: return TRUE;
86:
87: if (global_busy) /* break :global command */
88: ++global_busy;
89:
90: if (p_eb)
91: beep_flush(); /* also includes flush_buffers() */
92: else
93: flush_buffers(FALSE); /* flush internal buffers */
94: did_emsg = TRUE; /* flag for DoOneCmd() */
95: ++msg_scroll; /* don't overwrite a previous message */
96: (void)set_highlight('e'); /* set highlight mode for error messages */
97: msg_highlight = TRUE;
98: if (msg_scrolled)
99: need_wait_return = TRUE; /* needed in case emsg() is called after
100: * wait_return has reset need_wait_return
101: * and a redraw is expected because
102: * msg_scrolled is non-zero */
103:
104: /*
105: * First output name and line number of source of error message
106: */
107: if (sourcing_name != NULL &&
108: (sourcing_name != last_sourcing_name || sourcing_lnum != last_lnum)
109: && (Buf = alloc(MAXPATHL + 30)) != NULL)
110: {
111: ++no_wait_return;
112: if (sourcing_name != last_sourcing_name)
113: {
114: sprintf((char *)Buf, "Error detected while processing %s:",
115: sourcing_name);
116: msg(Buf);
117: msg_highlight = TRUE;
118: }
119: /* lnum is 0 when executing a command from the command line
120: * argument, we don't want a line number then */
121: if (sourcing_lnum != 0)
122: {
123: (void)set_highlight('n'); /* highlight mode for line numbers */
124: sprintf((char *)Buf, "line %4ld:", sourcing_lnum);
125: msg(Buf);
126: (void)set_highlight('e'); /* highlight mode for error messages */
127: msg_highlight = TRUE;
128: }
129: --no_wait_return;
130: last_lnum = sourcing_lnum; /* only once for each line */
131: vim_free(Buf);
132: }
133: last_sourcing_name = sourcing_name; /* do this also when it is NULL */
134:
135: #ifdef SLEEP_IN_EMSG
136: /*
137: * Msg returns TRUE if wait_return() was not called.
138: * In that case may call sleep() to give the user a chance to read the message.
139: * Don't call sleep() if dont_sleep is set.
140: */
141: retval = msg(s);
142: if (retval)
143: {
144: if (dont_sleep || need_wait_return)
145: need_sleep = TRUE; /* sleep before removing the message */
146: else
147: mch_delay(1000L, TRUE); /* give user chance to read message */
148: }
149: /* --msg_scroll; don't overwrite this message */
150: return retval;
151: #else
152: emsg_on_display = TRUE; /* remember there is an error message */
153: return msg(s);
154: #endif
155: }
156:
157: int
158: emsg2(s, a1)
159: char_u *s, *a1;
160: {
161: /* Check for NULL strings (just in case) */
162: if (a1 == NULL)
163: a1 = (char_u *)"[NULL]";
164: /* Check for very long strings (can happen with ":help ^A<CR>") */
165: if (STRLEN(s) + STRLEN(a1) >= IOSIZE)
166: a1 = (char_u *)"[string too long]";
167: sprintf((char *)IObuff, (char *)s, (char *)a1);
168: return emsg(IObuff);
169: }
170:
171: int
172: emsgn(s, n)
173: char_u *s;
174: long n;
175: {
176: sprintf((char *)IObuff, (char *)s, n);
177: return emsg(IObuff);
178: }
179:
180: /*
181: * Like msg(), but truncate to a single line if p_shm contains 't'.
182: * Careful: The string may be changed!
183: */
184: int
185: msg_trunc(s)
186: char_u *s;
187: {
188: int n;
189:
190: if (shortmess(SHM_TRUNC) && (n = (int)STRLEN(s) -
191: (int)(Rows - cmdline_row - 1) * Columns - sc_col + 1) > 0)
192: {
193: s[n] = '<';
194: return msg(s + n);
195: }
196: else
197: return msg(s);
198: }
199:
200: /*
201: * wait for the user to hit a key (normally a return)
202: * if 'redraw' is TRUE, clear and redraw the screen
203: * if 'redraw' is FALSE, just redraw the screen
204: * if 'redraw' is -1, don't redraw at all
205: */
206: void
207: wait_return(redraw)
208: int redraw;
209: {
210: int c;
211: int oldState;
212: int tmpState;
213:
214: if (redraw == TRUE)
215: must_redraw = CLEAR;
216:
217: /*
218: * With the global command (and some others) we only need one return at the
219: * end. Adjust cmdline_row to avoid the next message overwriting the last one.
220: */
221: if (no_wait_return)
222: {
223: need_wait_return = TRUE;
224: cmdline_row = msg_row;
225: return;
226: }
227: oldState = State;
228: if (quit_more)
229: {
230: c = CR; /* just pretend CR was hit */
231: quit_more = FALSE;
232: got_int = FALSE;
233: }
234: else
235: {
236: State = HITRETURN;
237: #ifdef USE_MOUSE
238: setmouse();
239: #endif
240: if (msg_didout) /* start on a new line */
241: msg_outchar('\n');
242: if (got_int)
243: MSG_OUTSTR("Interrupt: ");
244:
245: (void)set_highlight('r');
246: start_highlight();
247: #ifdef ORG_HITRETURN
248: MSG_OUTSTR("Press RETURN to continue");
249: stop_highlight();
250: do {
251: c = vgetc();
252: } while (vim_strchr((char_u *)"\r\n: ", c) == NULL);
253: if (c == ':') /* this can vi too (but not always!) */
254: stuffcharReadbuff(c);
255: #else
256: MSG_OUTSTR("Press RETURN or enter command to continue");
257: stop_highlight();
258: do
259: {
260: c = vgetc();
261: got_int = FALSE;
262: } while (c == Ctrl('C')
263: #ifdef USE_GUI
264: || c == K_SCROLLBAR || c == K_HORIZ_SCROLLBAR
265: #endif
266: #ifdef USE_MOUSE
267: || c == K_LEFTDRAG || c == K_LEFTRELEASE
268: || c == K_MIDDLEDRAG || c == K_MIDDLERELEASE
269: || c == K_RIGHTDRAG || c == K_RIGHTRELEASE
270: || c == K_IGNORE ||
271: (!mouse_has(MOUSE_RETURN) &&
272: (c == K_LEFTMOUSE ||
273: c == K_MIDDLEMOUSE ||
274: c == K_RIGHTMOUSE))
275: #endif
276: );
277: mch_breakcheck();
278: #ifdef USE_MOUSE
279: /*
280: * Avoid that the mouse-up event causes visual mode to start.
281: */
282: if (c == K_LEFTMOUSE || c == K_MIDDLEMOUSE || c == K_RIGHTMOUSE)
283: jump_to_mouse(MOUSE_SETPOS);
284: else
285: #endif
286: if (vim_strchr((char_u *)"\r\n ", c) == NULL)
287: {
288: stuffcharReadbuff(c);
289: do_redraw = TRUE; /* need a redraw even though there is
290: something in the stuff buffer */
291: }
292: #endif
293: }
294:
295: /*
296: * If the user hits ':', '?' or '/' we get a command line from the next
297: * line.
298: */
299: if (c == ':' || c == '?' || c == '/')
300: {
301: cmdline_row = msg_row;
302: skip_redraw = TRUE; /* skip redraw once */
303: do_redraw = FALSE;
304: }
305:
306: /*
307: * If the window size changed set_winsize() will redraw the screen.
308: * Otherwise the screen is only redrawn if 'redraw' is set and no ':' typed.
309: */
310: tmpState = State;
311: State = oldState; /* restore State before set_winsize */
312: #ifdef USE_MOUSE
313: setmouse();
314: #endif
315: msg_check();
316:
317: need_wait_return = FALSE;
318: emsg_on_display = FALSE; /* can delete error message now */
319: #ifdef SLEEP_IN_EMSG
320: need_sleep = FALSE; /* no need to call sleep() anymore */
321: #endif
322: msg_didany = FALSE; /* reset lines_left at next msg_start() */
323: lines_left = -1;
324: if (keep_msg != NULL && linetabsize(keep_msg) >=
325: (Rows - cmdline_row - 1) * Columns + sc_col)
326: keep_msg = NULL; /* don't redisplay message, it's too long */
327:
328: if (tmpState == SETWSIZE) /* got resize event while in vgetc() */
329: {
330: starttermcap(); /* start termcap before redrawing */
331: set_winsize(0, 0, FALSE);
332: }
333: else if (!skip_redraw && (redraw == TRUE || (msg_scrolled && redraw != -1)))
334: {
335: starttermcap(); /* start termcap before redrawing */
336: updateScreen(VALID);
337: }
338:
339: dont_wait_return = TRUE; /* don't wait again in main() */
340: }
341:
342: /*
343: * Prepare for outputting characters in the command line.
344: */
345: void
346: msg_start()
347: {
348: keep_msg = NULL; /* don't display old message now */
349: keep_msg_highlight = 0;
350: if (!msg_scroll && full_screen) /* overwrite last message */
351: msg_pos(cmdline_row, 0);
352: else if (msg_didout) /* start message on next line */
353: {
354: msg_outchar('\n');
355: cmdline_row = msg_row;
356: }
357: if (!msg_didany)
358: lines_left = cmdline_row;
359: msg_didout = FALSE; /* no output on current line yet */
360: cursor_off();
361: }
362:
363: /*
364: * Move message position. This should always be used after moving the cursor.
365: * Use negative value if row or col does not have to be changed.
366: */
367: void
368: msg_pos(row, col)
369: int row, col;
370: {
371: if (row >= 0)
372: msg_row = row;
373: if (col >= 0)
374: msg_col = col;
375: }
376:
377: void
378: msg_outchar(c)
379: int c;
380: {
381: char_u buf[4];
382:
383: if (IS_SPECIAL(c))
384: {
385: buf[0] = K_SPECIAL;
386: buf[1] = K_SECOND(c);
387: buf[2] = K_THIRD(c);
388: buf[3] = NUL;
389: }
390: else
391: {
392: buf[0] = c;
393: buf[1] = NUL;
394: }
395: msg_outstr(buf);
396: }
397:
398: void
399: msg_outnum(n)
400: long n;
401: {
402: char_u buf[20];
403:
404: sprintf((char *)buf, "%ld", n);
405: msg_outstr(buf);
406: }
407:
408: void
409: msg_home_replace(fname)
410: char_u *fname;
411: {
412: char_u *name;
413:
414: name = home_replace_save(NULL, fname);
415: if (name != NULL)
416: msg_outtrans(name);
417: vim_free(name);
418: }
419:
420: /*
421: * output 'len' characters in 'str' (including NULs) with translation
422: * if 'len' is -1, output upto a NUL character
423: * return the number of characters it takes on the screen
424: */
425: int
426: msg_outtrans(str)
427: register char_u *str;
428: {
429: return msg_outtrans_len(str, (int)STRLEN(str));
430: }
431:
432: int
433: msg_outtrans_len(str, len)
434: register char_u *str;
435: register int len;
436: {
437: int retval = 0;
438:
439: while (--len >= 0)
440: {
441: msg_outstr(transchar(*str));
442: retval += charsize(*str);
443: ++str;
444: }
445: return retval;
446: }
447:
448: /*
449: * Output the string 'str' upto a NUL character.
450: * Return the number of characters it takes on the screen.
451: *
452: * If K_SPECIAL is encountered, then it is taken in conjunction with the
453: * following character and shown as <F1>, <S-Up> etc. In addition, if 'all'
454: * is TRUE, then any other character which has its 8th bit set is shown as
455: * <M-x>, where x is the equivalent character without its 8th bit set. If a
456: * character is displayed in one of these special ways, is also highlighted
457: * (its highlight name is '8' in the p_hl variable).
458: * This function is used to show mappings, where we want to see how to type
459: * the character/string -- webb
460: */
461: int
462: msg_outtrans_special(str, all)
463: register char_u *str;
464: register int all; /* <M-a> etc as well as <F1> etc */
465: {
466: int retval = 0;
467: char_u *string;
468: int c;
469: int modifiers;
470:
471: set_highlight('8');
472: for (; *str; ++str)
473: {
474: c = *str;
475: if (c == K_SPECIAL && str[1] != NUL && str[2] != NUL)
476: {
477: modifiers = 0x0;
478: if (str[1] == KS_MODIFIER)
479: {
480: modifiers = str[2];
481: str += 3;
482: c = *str;
483: }
484: if (c == K_SPECIAL)
485: {
486: c = TO_SPECIAL(str[1], str[2]);
487: str += 2;
488: if (c == K_ZERO) /* display <Nul> as ^@ */
489: c = NUL;
490: }
491: if (IS_SPECIAL(c) || modifiers) /* special key */
492: {
493: string = get_special_key_name(c, modifiers);
494: start_highlight();
495: msg_outstr(string);
496: retval += STRLEN(string);
497: stop_highlight();
498: flushbuf(); /* Otherwise gets overwritten by spaces */
499: continue;
500: }
501: }
502: if ((c & 0x80) && all)
503: {
504: start_highlight();
505: MSG_OUTSTR("<M-");
506: msg_outstr(transchar(c & 0x7f));
507: retval += 2 + charsize(c & 0x7f);
508: MSG_OUTSTR(">");
509: stop_highlight();
510: }
511: else
512: {
513: msg_outstr(transchar(c));
514: retval += charsize(c);
515: }
516: }
517: return retval;
518: }
519:
520: /*
521: * print line for :p command
522: */
523: void
524: msg_prt_line(s)
525: char_u *s;
526: {
527: register int si = 0;
528: register int c;
529: register int col = 0;
530:
531: int n_extra = 0;
532: int n_spaces = 0;
533: char_u *p = NULL; /* init to make SASC shut up */
534: int n;
535:
536: for (;;)
537: {
538: if (n_extra)
539: {
540: --n_extra;
541: c = *p++;
542: }
543: else if (n_spaces)
544: {
545: --n_spaces;
546: c = ' ';
547: }
548: else
549: {
550: c = s[si++];
551: if (c == TAB && !curwin->w_p_list)
552: {
553: /* tab amount depends on current column */
554: n_spaces = curbuf->b_p_ts - col % curbuf->b_p_ts - 1;
555: c = ' ';
556: }
557: else if (c == NUL && curwin->w_p_list)
558: {
559: p = (char_u *)"";
560: n_extra = 1;
561: c = '$';
562: }
563: else if (c != NUL && (n = charsize(c)) > 1)
564: {
565: n_extra = n - 1;
566: p = transchar(c);
567: c = *p++;
568: }
569: }
570:
571: if (c == NUL)
572: break;
573:
574: msg_outchar(c);
575: col++;
576: }
577: }
578:
579: /*
580: * output a string to the screen at position msg_row, msg_col
581: * Update msg_row and msg_col for the next message.
582: */
583: void
584: msg_outstr(s)
585: char_u *s;
586: {
587: int oldState;
588: char_u buf[20];
589:
590: /*
591: * If there is no valid screen, use fprintf so we can see error messages.
592: * If termcap is not active, we may be writing in an alternate console
593: * window, cursor positioning may not work correctly (window size may be
594: * different, e.g. for WIN32 console).
595: */
596: if (!msg_check_screen()
597: #ifdef WIN32
598: || !termcap_active
599: #endif
600: )
601: {
602: #ifdef WIN32
603: mch_settmode(0); /* cook so that \r and \n are handled correctly */
604: #endif
605: fprintf(stderr, (char *)s);
606: msg_didout = TRUE; /* assume that line is not empty */
607: #ifdef WIN32
608: mch_settmode(1);
609: #endif
610: return;
611: }
612:
613: msg_didany = TRUE; /* remember that something was outputted */
614: while (*s)
615: {
616: /*
617: * The screen is scrolled up when:
618: * - When outputting a newline in the last row
619: * - when outputting a character in the last column of the last row
620: * (some terminals scroll automatically, some don't. To avoid
621: * problems we scroll ourselves)
622: */
623: if (msg_row >= Rows - 1 && (*s == '\n' || msg_col >= Columns - 1 ||
624: (*s == TAB && msg_col >= ((Columns - 1) & ~7))))
625: {
626: screen_del_lines(0, 0, 1, (int)Rows, TRUE); /* always works */
627: msg_row = Rows - 2;
628: if (msg_col >= Columns) /* can happen after screen resize */
629: msg_col = Columns - 1;
630: ++msg_scrolled;
631: need_wait_return = TRUE; /* may need wait_return in main() */
632: if (cmdline_row > 0)
633: --cmdline_row;
634: /*
635: * if screen is completely filled wait for a character
636: */
637: if (p_more && --lines_left == 0 && State != HITRETURN)
638: {
639: oldState = State;
640: State = ASKMORE;
641: #ifdef USE_MOUSE
642: setmouse();
643: #endif
644: msg_moremsg(FALSE);
645: for (;;)
646: {
647: /*
648: * Get a typed character directly from the user.
649: * Don't use vgetc(), it syncs undo and eats mapped
650: * characters. Disadvantage: Special keys and mouse
651: * cannot be used here, typeahead is ignored.
652: */
653: flushbuf();
654: (void)mch_inchar(buf, 20, -1L);
655: switch (buf[0])
656: {
657: case CR: /* one extra line */
658: case NL:
659: lines_left = 1;
660: break;
661: case ':': /* start new command line */
662: stuffcharReadbuff(':');
663: cmdline_row = Rows - 1; /* put ':' on this line */
664: skip_redraw = TRUE; /* skip redraw once */
665: dont_wait_return = TRUE; /* don't wait in main() */
666: /*FALLTHROUGH*/
667: case 'q': /* quit */
668: case Ctrl('C'):
669: got_int = TRUE;
670: quit_more = TRUE;
671: break;
672: case 'd': /* Down half a page */
673: lines_left = Rows / 2;
674: break;
675: case ' ': /* one extra page */
676: lines_left = Rows - 1;
677: break;
678: default: /* no valid response */
679: msg_moremsg(TRUE);
680: continue;
681: }
682: break;
683: }
684: /* clear the --more-- message */
685: screen_fill((int)Rows - 1, (int)Rows,
686: 0, (int)Columns, ' ', ' ');
687: State = oldState;
688: #ifdef USE_MOUSE
689: setmouse();
690: #endif
691: if (quit_more)
692: {
693: msg_row = Rows - 1;
694: msg_col = 0;
695: return; /* the string is not displayed! */
696: }
697: }
698: }
699: if (*s == '\n') /* go to next line */
700: {
701: msg_didout = FALSE; /* remember that line is empty */
702: msg_col = 0;
703: if (++msg_row >= Rows) /* safety check */
704: msg_row = Rows - 1;
705: }
706: else if (*s == '\r') /* go to column 0 */
707: {
708: msg_col = 0;
709: }
710: else if (*s == '\b') /* go to previous char */
711: {
712: if (msg_col)
713: --msg_col;
714: }
715: else if (*s == TAB) /* translate into spaces */
716: {
717: do
718: msg_screen_outchar(' ');
719: while (msg_col & 7);
720: }
721: else
722: msg_screen_outchar(*s);
723: ++s;
724: }
725: }
726:
727: static void
728: msg_screen_outchar(c)
729: int c;
730: {
731: msg_didout = TRUE; /* remember that line is not empty */
732: screen_outchar(c, msg_row, msg_col);
733: if (++msg_col >= Columns)
734: {
735: msg_col = 0;
736: ++msg_row;
737: }
738: }
739:
740: void
741: msg_moremsg(full)
742: int full;
743: {
744: /*
745: * Need to restore old highlighting when we've finished with it
746: * because the output that's paging may be relying on it not
747: * changing -- webb
748: */
749: remember_highlight();
750: set_highlight('m');
751: start_highlight();
752: screen_msg((char_u *)"-- More --", (int)Rows - 1, 0);
753: if (full)
754: screen_msg((char_u *)" (RET: line, SPACE: page, d: half page, q: quit)",
755: (int)Rows - 1, 10);
756: stop_highlight();
757: recover_old_highlight();
758: }
759:
760: /*
761: * msg_check_screen - check if the screen is initialized.
762: * Also check msg_row and msg_col, if they are too big it may cause a crash.
763: */
764: static int
765: msg_check_screen()
766: {
767: if (!full_screen || !screen_valid(FALSE))
768: return FALSE;
769:
770: if (msg_row >= Rows)
771: msg_row = Rows - 1;
772: if (msg_col >= Columns)
773: msg_col = Columns - 1;
774: return TRUE;
775: }
776:
777: /*
778: * clear from current message position to end of screen
779: * Note: msg_col is not updated, so we remember the end of the message
780: * for msg_check().
781: */
782: void
783: msg_clr_eos()
784: {
785: if (!msg_check_screen()
786: #ifdef WIN32
787: || !termcap_active
788: #endif
789: )
790: return;
791: screen_fill(msg_row, msg_row + 1, msg_col, (int)Columns, ' ', ' ');
792: screen_fill(msg_row + 1, (int)Rows, 0, (int)Columns, ' ', ' ');
793: }
794:
795: /*
796: * end putting a message on the screen
797: * call wait_return if the message does not fit in the available space
798: * return TRUE if wait_return not called.
799: */
800: int
801: msg_end()
802: {
803: /*
804: * if the string is larger than the window,
805: * or the ruler option is set and we run into it,
806: * we have to redraw the window.
807: * Do not do this if we are abandoning the file or editing the command line.
808: */
809: if (!exiting && msg_check() && State != CMDLINE)
810: {
811: wait_return(FALSE);
812: return FALSE;
813: }
814: flushbuf();
815: return TRUE;
816: }
817:
818: /*
819: * If the written message has caused the screen to scroll up, or if we
820: * run into the shown command or ruler, we have to redraw the window later.
821: */
822: int
823: msg_check()
824: {
825: if (msg_scrolled || (msg_row == Rows - 1 && msg_col >= sc_col))
826: {
827: redraw_later(NOT_VALID);
828: redraw_cmdline = TRUE;
829: return TRUE;
830: }
831: return FALSE;
832: }