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