1 /*-
2 * Copyright (c) 1993, 1994
3 * The Regents of the University of California. All rights reserved.
4 * Copyright (c) 1993, 1994, 1995, 1996
5 * Keith Bostic. All rights reserved.
6 *
7 * See the LICENSE file for redistribution information.
8 */
9
10 #include "config.h"
11
12 #ifndef lint
13 static const char sccsid[] = "$Id: cl_funcs.c,v 10.74 2012/10/11 10:30:16 zy Exp $";
14 #endif /* not lint */
15
16 #include <sys/types.h>
17 #include <sys/queue.h>
18 #include <sys/time.h>
19
20 #include <bitstring.h>
21 #include <ctype.h>
22 #include <signal.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #ifdef HAVE_TERM_H
27 #include <term.h>
28 #endif
29 #include <termios.h>
30 #include <unistd.h>
31
32 #include "../common/common.h"
33 #include "../vi/vi.h"
34 #include "cl.h"
35
36 static void cl_rdiv(SCR *);
37
38 static int
addstr4(SCR * sp,void * str,size_t len,int wide)39 addstr4(SCR *sp, void *str, size_t len, int wide)
40 {
41 CL_PRIVATE *clp;
42 WINDOW *win;
43 size_t y, x;
44 int iv;
45
46 clp = CLP(sp);
47 win = CLSP(sp) ? CLSP(sp) : stdscr;
48
49 /*
50 * If ex isn't in control, it's the last line of the screen and
51 * it's a split screen, use inverse video.
52 */
53 iv = 0;
54 getyx(win, y, x);
55 if (!F_ISSET(sp, SC_SCR_EXWROTE) &&
56 y == RLNO(sp, LASTLINE(sp)) && IS_SPLIT(sp)) {
57 iv = 1;
58 (void)wstandout(win);
59 }
60
61 #ifdef USE_WIDECHAR
62 if (wide) {
63 if (waddnwstr(win, str, len) == ERR)
64 return (1);
65 } else
66 #endif
67 if (waddnstr(win, str, len) == ERR)
68 return (1);
69
70 if (iv)
71 (void)wstandend(win);
72 return (0);
73 }
74
75 /*
76 * cl_waddstr --
77 * Add len bytes from the string at the cursor, advancing the cursor.
78 *
79 * PUBLIC: int cl_waddstr(SCR *, const CHAR_T *, size_t);
80 */
81 int
cl_waddstr(SCR * sp,const CHAR_T * str,size_t len)82 cl_waddstr(SCR *sp, const CHAR_T *str, size_t len)
83 {
84 return addstr4(sp, (void *)str, len, 1);
85 }
86
87 /*
88 * cl_addstr --
89 * Add len bytes from the string at the cursor, advancing the cursor.
90 *
91 * PUBLIC: int cl_addstr(SCR *, const char *, size_t);
92 */
93 int
cl_addstr(SCR * sp,const char * str,size_t len)94 cl_addstr(SCR *sp, const char *str, size_t len)
95 {
96 return addstr4(sp, (void *)str, len, 0);
97 }
98
99 /*
100 * cl_attr --
101 * Toggle a screen attribute on/off.
102 *
103 * PUBLIC: int cl_attr(SCR *, scr_attr_t, int);
104 */
105 int
cl_attr(SCR * sp,scr_attr_t attribute,int on)106 cl_attr(SCR *sp, scr_attr_t attribute, int on)
107 {
108 CL_PRIVATE *clp;
109 WINDOW *win;
110
111 clp = CLP(sp);
112 win = CLSP(sp) ? CLSP(sp) : stdscr;
113
114 switch (attribute) {
115 case SA_ALTERNATE:
116 /*
117 * !!!
118 * There's a major layering violation here. The problem is that the
119 * X11 xterm screen has what's known as an "alternate" screen. Some
120 * xterm termcap/terminfo entries include sequences to switch to/from
121 * that alternate screen as part of the ti/te (smcup/rmcup) strings.
122 * Vi runs in the alternate screen, so that you are returned to the
123 * same screen contents on exit from vi that you had when you entered
124 * vi. Further, when you run :shell, or :!date or similar ex commands,
125 * you also see the original screen contents. This wasn't deliberate
126 * on vi's part, it's just that it historically sent terminal init/end
127 * sequences at those times, and the addition of the alternate screen
128 * sequences to the strings changed the behavior of vi. The problem
129 * caused by this is that we don't want to switch back to the alternate
130 * screen while getting a new command from the user, when the user is
131 * continuing to enter ex commands, e.g.:
132 *
133 * :!date <<< switch to original screen
134 * [Hit return to continue] <<< prompt user to continue
135 * :command <<< get command from user
136 *
137 * Note that the :command input is a true vi input mode, e.g., input
138 * maps and abbreviations are being done. So, we need to be able to
139 * switch back into the vi screen mode, without flashing the screen.
140 *
141 * To make matters worse, the curses initscr() and endwin() calls will
142 * do this automatically -- so, this attribute isn't as controlled by
143 * the higher level screen as closely as one might like.
144 */
145 if (on) {
146 if (clp->ti_te != TI_SENT) {
147 clp->ti_te = TI_SENT;
148 if (clp->smcup == NULL)
149 (void)cl_getcap(sp, "smcup", &clp->smcup);
150 if (clp->smcup != NULL)
151 (void)tputs(clp->smcup, 1, cl_putchar);
152 }
153 } else
154 if (clp->ti_te != TE_SENT) {
155 clp->ti_te = TE_SENT;
156 if (clp->rmcup == NULL)
157 (void)cl_getcap(sp, "rmcup", &clp->rmcup);
158 if (clp->rmcup != NULL)
159 (void)tputs(clp->rmcup, 1, cl_putchar);
160 (void)fflush(stdout);
161 }
162 (void)fflush(stdout);
163 break;
164 case SA_INVERSE:
165 if (F_ISSET(sp, SC_EX | SC_SCR_EXWROTE)) {
166 if (clp->smso == NULL)
167 return (1);
168 if (on)
169 (void)tputs(clp->smso, 1, cl_putchar);
170 else
171 (void)tputs(clp->rmso, 1, cl_putchar);
172 (void)fflush(stdout);
173 } else {
174 if (on)
175 (void)wstandout(win);
176 else
177 (void)wstandend(win);
178 }
179 break;
180 default:
181 abort();
182 }
183 return (0);
184 }
185
186 /*
187 * cl_baud --
188 * Return the baud rate.
189 *
190 * PUBLIC: int cl_baud(SCR *, u_long *);
191 */
192 int
cl_baud(SCR * sp,u_long * ratep)193 cl_baud(SCR *sp, u_long *ratep)
194 {
195 CL_PRIVATE *clp;
196
197 /*
198 * XXX
199 * There's no portable way to get a "baud rate" -- cfgetospeed(3)
200 * returns the value associated with some #define, which we may
201 * never have heard of, or which may be a purely local speed. Vi
202 * only cares if it's SLOW (w300), slow (w1200) or fast (w9600).
203 * Try and detect the slow ones, and default to fast.
204 */
205 clp = CLP(sp);
206 switch (cfgetospeed(&clp->orig)) {
207 case B50:
208 case B75:
209 case B110:
210 case B134:
211 case B150:
212 case B200:
213 case B300:
214 case B600:
215 *ratep = 600;
216 break;
217 case B1200:
218 *ratep = 1200;
219 break;
220 default:
221 *ratep = 9600;
222 break;
223 }
224 return (0);
225 }
226
227 /*
228 * cl_bell --
229 * Ring the bell/flash the screen.
230 *
231 * PUBLIC: int cl_bell(SCR *);
232 */
233 int
cl_bell(SCR * sp)234 cl_bell(SCR *sp)
235 {
236 if (F_ISSET(sp, SC_EX | SC_SCR_EXWROTE | SC_SCR_EX))
237 (void)write(STDOUT_FILENO, "\07", 1); /* \a */
238 else {
239 /*
240 * Vi has an edit option which determines if the terminal
241 * should be beeped or the screen flashed.
242 */
243 if (O_ISSET(sp, O_FLASH))
244 (void)flash();
245 else
246 (void)beep();
247 }
248 return (0);
249 }
250
251 /*
252 * cl_clrtoeol --
253 * Clear from the current cursor to the end of the line.
254 *
255 * PUBLIC: int cl_clrtoeol(SCR *);
256 */
257 int
cl_clrtoeol(SCR * sp)258 cl_clrtoeol(SCR *sp)
259 {
260 WINDOW *win;
261 #if 0
262 size_t spcnt, y, x;
263 #endif
264
265 win = CLSP(sp) ? CLSP(sp) : stdscr;
266
267 #if 0
268 if (IS_VSPLIT(sp)) {
269 /* The cursor must be returned to its original position. */
270 getyx(win, y, x);
271 for (spcnt = (sp->coff + sp->cols) - x; spcnt > 0; --spcnt)
272 (void)waddch(win, ' ');
273 (void)wmove(win, y, x);
274 return (0);
275 } else
276 #endif
277 return (wclrtoeol(win) == ERR);
278 }
279
280 /*
281 * cl_cursor --
282 * Return the current cursor position.
283 *
284 * PUBLIC: int cl_cursor(SCR *, size_t *, size_t *);
285 */
286 int
cl_cursor(SCR * sp,size_t * yp,size_t * xp)287 cl_cursor(SCR *sp, size_t *yp, size_t *xp)
288 {
289 WINDOW *win;
290 win = CLSP(sp) ? CLSP(sp) : stdscr;
291 /*
292 * The curses screen support splits a single underlying curses screen
293 * into multiple screens to support split screen semantics. For this
294 * reason the returned value must be adjusted to be relative to the
295 * current screen, and not absolute. Screens that implement the split
296 * using physically distinct screens won't need this hack.
297 */
298 getyx(win, *yp, *xp);
299 /*
300 *yp -= sp->roff;
301 *xp -= sp->coff;
302 */
303 return (0);
304 }
305
306 /*
307 * cl_deleteln --
308 * Delete the current line, scrolling all lines below it.
309 *
310 * PUBLIC: int cl_deleteln(SCR *);
311 */
312 int
cl_deleteln(SCR * sp)313 cl_deleteln(SCR *sp)
314 {
315 CL_PRIVATE *clp;
316 WINDOW *win;
317 size_t y, x;
318
319 clp = CLP(sp);
320 win = CLSP(sp) ? CLSP(sp) : stdscr;
321
322 /*
323 * This clause is required because the curses screen uses reverse
324 * video to delimit split screens. If the screen does not do this,
325 * this code won't be necessary.
326 *
327 * If the bottom line was in reverse video, rewrite it in normal
328 * video before it's scrolled.
329 */
330 if (!F_ISSET(sp, SC_SCR_EXWROTE) && IS_SPLIT(sp)) {
331 getyx(win, y, x);
332 mvwchgat(win, RLNO(sp, LASTLINE(sp)), 0, -1, A_NORMAL, 0, NULL);
333 (void)wmove(win, y, x);
334 }
335
336 /*
337 * The bottom line is expected to be blank after this operation,
338 * and other screens must support that semantic.
339 */
340 return (wdeleteln(win) == ERR);
341 }
342
343 /*
344 * cl_discard --
345 * Discard a screen.
346 *
347 * PUBLIC: int cl_discard(SCR *, SCR **);
348 */
349 int
cl_discard(SCR * discardp,SCR ** acquirep)350 cl_discard(SCR *discardp, SCR **acquirep)
351 {
352 CL_PRIVATE *clp;
353 SCR* tsp;
354
355 if (discardp) {
356 clp = CLP(discardp);
357 F_SET(clp, CL_LAYOUT);
358
359 if (CLSP(discardp)) {
360 delwin(CLSP(discardp));
361 discardp->cl_private = NULL;
362 }
363 }
364
365 /* no screens got a piece; we're done */
366 if (!acquirep)
367 return 0;
368
369 for (; (tsp = *acquirep) != NULL; ++acquirep) {
370 clp = CLP(tsp);
371 F_SET(clp, CL_LAYOUT);
372
373 if (CLSP(tsp))
374 delwin(CLSP(tsp));
375 tsp->cl_private = subwin(stdscr, tsp->rows, tsp->cols,
376 tsp->roff, tsp->coff);
377 }
378
379 /* discardp is going away, acquirep is taking up its space. */
380 return (0);
381 }
382
383 /*
384 * cl_ex_adjust --
385 * Adjust the screen for ex. This routine is purely for standalone
386 * ex programs. All special purpose, all special case.
387 *
388 * PUBLIC: int cl_ex_adjust(SCR *, exadj_t);
389 */
390 int
cl_ex_adjust(SCR * sp,exadj_t action)391 cl_ex_adjust(SCR *sp, exadj_t action)
392 {
393 CL_PRIVATE *clp;
394 int cnt;
395
396 clp = CLP(sp);
397 switch (action) {
398 case EX_TERM_SCROLL:
399 /* Move the cursor up one line if that's possible. */
400 if (clp->cuu1 != NULL)
401 (void)tputs(clp->cuu1, 1, cl_putchar);
402 else if (clp->cup != NULL)
403 (void)tputs(tgoto(clp->cup,
404 0, LINES - 2), 1, cl_putchar);
405 else
406 return (0);
407 /* FALLTHROUGH */
408 case EX_TERM_CE:
409 /* Clear the line. */
410 if (clp->el != NULL) {
411 (void)putchar('\r');
412 (void)tputs(clp->el, 1, cl_putchar);
413 } else {
414 /*
415 * Historically, ex didn't erase the line, so, if the
416 * displayed line was only a single glyph, and <eof>
417 * was more than one glyph, the output would not fully
418 * overwrite the user's input. To fix this, output
419 * the maxiumum character number of spaces. Note,
420 * this won't help if the user entered extra prompt
421 * or <blank> characters before the command character.
422 * We'd have to do a lot of work to make that work, and
423 * it's almost certainly not worth the effort.
424 */
425 for (cnt = 0; cnt < MAX_CHARACTER_COLUMNS; ++cnt)
426 (void)putchar('\b');
427 for (cnt = 0; cnt < MAX_CHARACTER_COLUMNS; ++cnt)
428 (void)putchar(' ');
429 (void)putchar('\r');
430 (void)fflush(stdout);
431 }
432 break;
433 default:
434 abort();
435 }
436 return (0);
437 }
438
439 /*
440 * cl_insertln --
441 * Push down the current line, discarding the bottom line.
442 *
443 * PUBLIC: int cl_insertln(SCR *);
444 */
445 int
cl_insertln(SCR * sp)446 cl_insertln(SCR *sp)
447 {
448 WINDOW *win;
449 win = CLSP(sp) ? CLSP(sp) : stdscr;
450 /*
451 * The current line is expected to be blank after this operation,
452 * and the screen must support that semantic.
453 */
454 return (winsertln(win) == ERR);
455 }
456
457 /*
458 * cl_keyval --
459 * Return the value for a special key.
460 *
461 * PUBLIC: int cl_keyval(SCR *, scr_keyval_t, CHAR_T *, int *);
462 */
463 int
cl_keyval(SCR * sp,scr_keyval_t val,CHAR_T * chp,int * dnep)464 cl_keyval(SCR *sp, scr_keyval_t val, CHAR_T *chp, int *dnep)
465 {
466 CL_PRIVATE *clp;
467
468 /*
469 * VEOF, VERASE and VKILL are required by POSIX 1003.1-1990,
470 * VWERASE is a 4BSD extension.
471 */
472 clp = CLP(sp);
473 switch (val) {
474 case KEY_VEOF:
475 *dnep = (*chp = clp->orig.c_cc[VEOF]) == _POSIX_VDISABLE;
476 break;
477 case KEY_VERASE:
478 *dnep = (*chp = clp->orig.c_cc[VERASE]) == _POSIX_VDISABLE;
479 break;
480 case KEY_VKILL:
481 *dnep = (*chp = clp->orig.c_cc[VKILL]) == _POSIX_VDISABLE;
482 break;
483 #ifdef VWERASE
484 case KEY_VWERASE:
485 *dnep = (*chp = clp->orig.c_cc[VWERASE]) == _POSIX_VDISABLE;
486 break;
487 #endif
488 default:
489 *dnep = 1;
490 break;
491 }
492 return (0);
493 }
494
495 /*
496 * cl_move --
497 * Move the cursor.
498 *
499 * PUBLIC: int cl_move(SCR *, size_t, size_t);
500 */
501 int
cl_move(SCR * sp,size_t lno,size_t cno)502 cl_move(SCR *sp, size_t lno, size_t cno)
503 {
504 WINDOW *win;
505 win = CLSP(sp) ? CLSP(sp) : stdscr;
506 /* See the comment in cl_cursor. */
507 if (wmove(win, RLNO(sp, lno), RCNO(sp, cno)) == ERR) {
508 msgq(sp, M_ERR, "Error: move: l(%zu + %zu) c(%zu + %zu)",
509 lno, sp->roff, cno, sp->coff);
510 return (1);
511 }
512 return (0);
513 }
514
515 /*
516 * cl_refresh --
517 * Refresh the screen.
518 *
519 * PUBLIC: int cl_refresh(SCR *, int);
520 */
521 int
cl_refresh(SCR * sp,int repaint)522 cl_refresh(SCR *sp, int repaint)
523 {
524 GS *gp;
525 CL_PRIVATE *clp;
526 WINDOW *win;
527 SCR *psp, *tsp;
528 size_t y, x;
529
530 gp = sp->gp;
531 clp = CLP(sp);
532 win = CLSP(sp) ? CLSP(sp) : stdscr;
533
534 /*
535 * If we received a killer signal, we're done, there's no point
536 * in refreshing the screen.
537 */
538 if (clp->killersig)
539 return (0);
540
541 /*
542 * If repaint is set, the editor is telling us that we don't know
543 * what's on the screen, so we have to repaint from scratch.
544 *
545 * If repaint set or the screen layout changed, we need to redraw
546 * any lines separating vertically split screens. If the horizontal
547 * offsets are the same, then the split was vertical, and need to
548 * draw a dividing line.
549 */
550 if (repaint || F_ISSET(clp, CL_LAYOUT)) {
551 getyx(stdscr, y, x);
552 for (psp = sp; psp != NULL; psp = TAILQ_NEXT(psp, q))
553 for (tsp = TAILQ_NEXT(psp, q); tsp != NULL;
554 tsp = TAILQ_NEXT(tsp, q))
555 if (psp->roff == tsp->roff) {
556 if (psp->coff + psp->cols + 1 == tsp->coff)
557 cl_rdiv(psp);
558 else
559 if (tsp->coff + tsp->cols + 1 == psp->coff)
560 cl_rdiv(tsp);
561 }
562 (void)wmove(stdscr, y, x);
563 F_CLR(clp, CL_LAYOUT);
564 }
565
566 /*
567 * In the curses library, doing wrefresh(curscr) is okay, but the
568 * screen flashes when we then apply the refresh() to bring it up
569 * to date. So, use clearok().
570 */
571 if (repaint)
572 clearok(curscr, 1);
573 /*
574 * Only do an actual refresh, when this is the focus window,
575 * i.e. the one holding the cursor. This assumes that refresh
576 * is called for that window after refreshing the others.
577 * This prevents the cursor being drawn in the other windows.
578 */
579 return (wnoutrefresh(stdscr) == ERR ||
580 wnoutrefresh(win) == ERR ||
581 (sp == clp->focus && doupdate() == ERR));
582 }
583
584 /*
585 * cl_rdiv --
586 * Draw a dividing line between two vertically split screens.
587 */
588 static void
cl_rdiv(SCR * sp)589 cl_rdiv(SCR *sp)
590 {
591 #ifdef __NetBSD__
592 mvvline(sp->roff, sp->cols + sp->coff, '|', sp->rows);
593 #else
594 mvvline(sp->roff, sp->cols + sp->coff, ACS_VLINE, sp->rows);
595 #endif
596 }
597
598 /*
599 * cl_rename --
600 * Rename the file.
601 *
602 * PUBLIC: int cl_rename(SCR *, char *, int);
603 */
604 int
cl_rename(SCR * sp,char * name,int on)605 cl_rename(SCR *sp, char *name, int on)
606 {
607 GS *gp;
608 CL_PRIVATE *clp;
609 FILE *pfp;
610 char buf[256], *s, *e;
611 char * wid;
612 char cmd[64];
613
614 gp = sp->gp;
615 clp = CLP(sp);
616
617 /*
618 * XXX
619 * We can only rename windows for xterm.
620 */
621 if (on) {
622 clp->focus = sp;
623 if (!F_ISSET(clp, CL_RENAME_OK) ||
624 strncmp(OG_STR(gp, GO_TERM), "xterm", 5))
625 return (0);
626
627 if (clp->oname == NULL && (wid = getenv("WINDOWID"))) {
628 snprintf(cmd, sizeof(cmd), "xprop -id %s WM_NAME", wid);
629 if ((pfp = popen(cmd, "r")) == NULL)
630 goto rename;
631 if (fgets(buf, sizeof(buf), pfp) == NULL) {
632 pclose(pfp);
633 goto rename;
634 }
635 pclose(pfp);
636 if ((s = strchr(buf, '"')) != NULL &&
637 (e = strrchr(buf, '"')) != NULL)
638 clp->oname = strndup(s + 1, e - s - 1);
639 }
640
641 rename: cl_setname(gp, name);
642
643 F_SET(clp, CL_RENAME);
644 } else
645 if (F_ISSET(clp, CL_RENAME)) {
646 cl_setname(gp, clp->oname);
647
648 F_CLR(clp, CL_RENAME);
649 }
650 return (0);
651 }
652
653 /*
654 * cl_setname --
655 * Set a X11 icon/window name.
656 *
657 * PUBLIC: void cl_setname(GS *, char *);
658 */
659 void
cl_setname(GS * gp,char * name)660 cl_setname(GS *gp, char *name)
661 {
662 /* X11 xterm escape sequence to rename the icon/window. */
663 #define XTERM_RENAME "\033]0;%s\007"
664
665 (void)printf(XTERM_RENAME, name == NULL ? OG_STR(gp, GO_TERM) : name);
666 (void)fflush(stdout);
667 #undef XTERM_RENAME
668 }
669
670 /*
671 * cl_split --
672 * Split a screen.
673 *
674 * PUBLIC: int cl_split(SCR *, SCR *);
675 */
676 int
cl_split(SCR * origp,SCR * newp)677 cl_split(SCR *origp, SCR *newp)
678 {
679 CL_PRIVATE *clp;
680
681 clp = CLP(origp);
682 F_SET(clp, CL_LAYOUT);
683
684 if (CLSP(origp))
685 delwin(CLSP(origp));
686
687 origp->cl_private = subwin(stdscr, origp->rows, origp->cols,
688 origp->roff, origp->coff);
689 newp->cl_private = subwin(stdscr, newp->rows, newp->cols,
690 newp->roff, newp->coff);
691
692 /* origp is the original screen, giving up space to newp. */
693 return (0);
694 }
695
696 /*
697 * cl_suspend --
698 * Suspend a screen.
699 *
700 * PUBLIC: int cl_suspend(SCR *, int *);
701 */
702 int
cl_suspend(SCR * sp,int * allowedp)703 cl_suspend(SCR *sp, int *allowedp)
704 {
705 struct termios t;
706 CL_PRIVATE *clp;
707 WINDOW *win;
708 GS *gp;
709 size_t y, x;
710 int changed;
711
712 gp = sp->gp;
713 clp = CLP(sp);
714 win = CLSP(sp) ? CLSP(sp) : stdscr;
715 *allowedp = 1;
716
717 /*
718 * The ex implementation of this function isn't needed by screens not
719 * supporting ex commands that require full terminal canonical mode
720 * (e.g. :suspend).
721 *
722 * The vi implementation of this function isn't needed by screens not
723 * supporting vi process suspension, i.e. any screen that isn't backed
724 * by a UNIX shell.
725 *
726 * Setting allowedp to 0 will cause the editor to reject the command.
727 */
728 if (F_ISSET(sp, SC_EX)) {
729 /* Save the terminal settings, and restore the original ones. */
730 if (F_ISSET(clp, CL_STDIN_TTY)) {
731 (void)tcgetattr(STDIN_FILENO, &t);
732 (void)tcsetattr(STDIN_FILENO,
733 TCSASOFT | TCSADRAIN, &clp->orig);
734 }
735
736 /* Stop the process group. */
737 (void)kill(0, SIGTSTP);
738
739 /* Time passes ... */
740
741 /* Restore terminal settings. */
742 if (F_ISSET(clp, CL_STDIN_TTY))
743 (void)tcsetattr(STDIN_FILENO, TCSASOFT | TCSADRAIN, &t);
744 return (0);
745 }
746
747 /*
748 * Move to the lower left-hand corner of the screen.
749 *
750 * XXX
751 * Not sure this is necessary in System V implementations, but it
752 * shouldn't hurt.
753 */
754 getyx(win, y, x);
755 (void)wmove(win, LINES - 1, 0);
756 (void)wrefresh(win);
757
758 /*
759 * Temporarily end the screen. System V introduced a semantic where
760 * endwin() could be restarted. We use it because restarting curses
761 * from scratch often fails in System V. 4BSD curses didn't support
762 * restarting after endwin(), so we have to do what clean up we can
763 * without calling it.
764 */
765 /* Save the terminal settings. */
766 (void)tcgetattr(STDIN_FILENO, &t);
767
768 /* Restore the cursor keys to normal mode. */
769 (void)keypad(stdscr, FALSE);
770
771 /* Restore the window name. */
772 (void)cl_rename(sp, NULL, 0);
773
774 (void)endwin();
775
776 /*
777 * XXX
778 * Restore the original terminal settings. This is bad -- the
779 * reset can cause character loss from the tty queue. However,
780 * we can't call endwin() in BSD curses implementations, and too
781 * many System V curses implementations don't get it right.
782 */
783 (void)tcsetattr(STDIN_FILENO, TCSADRAIN | TCSASOFT, &clp->orig);
784
785 /* Stop the process group. */
786 (void)kill(0, SIGTSTP);
787
788 /* Time passes ... */
789
790 /*
791 * If we received a killer signal, we're done. Leave everything
792 * unchanged. In addition, the terminal has already been reset
793 * correctly, so leave it alone.
794 */
795 if (clp->killersig) {
796 F_CLR(clp, CL_SCR_EX_INIT | CL_SCR_VI_INIT);
797 return (0);
798 }
799
800 /* Restore terminal settings. */
801 wrefresh(win); /* Needed on SunOs/Solaris ? */
802 if (F_ISSET(clp, CL_STDIN_TTY))
803 (void)tcsetattr(STDIN_FILENO, TCSASOFT | TCSADRAIN, &t);
804
805 /* Set the window name. */
806 (void)cl_rename(sp, sp->frp->name, 1);
807
808 /* Put the cursor keys into application mode. */
809 (void)keypad(stdscr, TRUE);
810
811 /* Refresh and repaint the screen. */
812 (void)wmove(win, y, x);
813 (void)cl_refresh(sp, 1);
814
815 /* If the screen changed size, set the SIGWINCH bit. */
816 if (cl_ssize(sp, 1, NULL, NULL, &changed))
817 return (1);
818 if (changed)
819 F_SET(CLP(sp), CL_SIGWINCH);
820
821 return (0);
822 }
823
824 /*
825 * cl_usage --
826 * Print out the curses usage messages.
827 *
828 * PUBLIC: void cl_usage(void);
829 */
830 void
cl_usage(void)831 cl_usage(void)
832 {
833 #define USAGE "\
834 usage: ex [-eFRrSsv] [-c command] [-t tag] [-w size] [file ...]\n\
835 usage: vi [-eFlRrSv] [-c command] [-t tag] [-w size] [file ...]\n"
836 (void)fprintf(stderr, "%s", USAGE);
837 #undef USAGE
838 }
839
840 #ifdef DEBUG
841 /*
842 * gdbrefresh --
843 * Stub routine so can flush out curses screen changes using gdb.
844 */
845 static int
846 __attribute__((unused))
gdbrefresh(void)847 gdbrefresh(void)
848 {
849 refresh();
850 return (0); /* XXX Convince gdb to run it. */
851 }
852 #endif
853