Merge from vendor branch DHCP:
[dragonfly.git] / contrib / nvi / cl / cl_term.c
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[] = "@(#)cl_term.c     10.22 (Berkeley) 9/15/96";
14 #endif /* not lint */
15
16 #include <sys/types.h>
17 #include <sys/ioctl.h>
18 #include <sys/queue.h>
19 #include <sys/stat.h>
20
21 #include <bitstring.h>
22 #include <curses.h>
23 #include <errno.h>
24 #include <limits.h>
25 #include <signal.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <termios.h>
30 #include <unistd.h>
31
32 #include "../common/common.h"
33 #include "cl.h"
34
35 static int cl_pfmap __P((SCR *, seq_t, CHAR_T *, size_t, CHAR_T *, size_t));
36
37 /*
38  * XXX
39  * THIS REQUIRES THAT ALL SCREENS SHARE A TERMINAL TYPE.
40  */
41 typedef struct _tklist {
42         char    *ts;                    /* Key's termcap string. */
43         char    *output;                /* Corresponding vi command. */
44         char    *name;                  /* Name. */
45         u_char   value;                 /* Special value (for lookup). */
46 } TKLIST;
47 static TKLIST const c_tklist[] = {      /* Command mappings. */
48         {"kil1",        "O",    "insert line"},
49         {"kdch1",       "x",    "delete character"},
50         {"kcud1",       "j",    "cursor down"},
51         {"kel",         "D",    "delete to eol"},
52         {"kind",     "\004",    "scroll down"},                 /* ^D */
53         {"kll",         "$",    "go to eol"},
54         {"kend",        "$",    "go to eol"},
55         {"khome",       "^",    "go to sol"},
56         {"kich1",       "i",    "insert at cursor"},
57         {"kdl1",       "dd",    "delete line"},
58         {"kcub1",       "h",    "cursor left"},
59         {"knp",      "\006",    "page down"},                   /* ^F */
60         {"kpp",      "\002",    "page up"},                     /* ^B */
61         {"kri",      "\025",    "scroll up"},                   /* ^U */
62         {"ked",        "dG",    "delete to end of screen"},
63         {"kcuf1",       "l",    "cursor right"},
64         {"kcuu1",       "k",    "cursor up"},
65         {NULL},
66 };
67 static TKLIST const m1_tklist[] = {     /* Input mappings (lookup). */
68         {NULL},
69 };
70 static TKLIST const m2_tklist[] = {     /* Input mappings (set or delete). */
71         {"kcud1",  "\033ja",    "cursor down"},                 /* ^[ja */
72         {"kcub1",  "\033ha",    "cursor left"},                 /* ^[ha */
73         {"kcuu1",  "\033ka",    "cursor up"},                   /* ^[ka */
74         {"kcuf1",  "\033la",    "cursor right"},                /* ^[la */
75         {NULL},
76 };
77
78 /*
79  * cl_term_init --
80  *      Initialize the special keys defined by the termcap/terminfo entry.
81  *
82  * PUBLIC: int cl_term_init __P((SCR *));
83  */
84 int
85 cl_term_init(sp)
86         SCR *sp;
87 {
88         KEYLIST *kp;
89         SEQ *qp;
90         TKLIST const *tkp;
91         char *t;
92
93         /* Command mappings. */
94         for (tkp = c_tklist; tkp->name != NULL; ++tkp) {
95                 if ((t = tigetstr(tkp->ts)) == NULL || t == (char *)-1)
96                         continue;
97                 if (seq_set(sp, tkp->name, strlen(tkp->name), t, strlen(t),
98                     tkp->output, strlen(tkp->output), SEQ_COMMAND,
99                     SEQ_NOOVERWRITE | SEQ_SCREEN))
100                         return (1);
101         }
102
103         /* Input mappings needing to be looked up. */
104         for (tkp = m1_tklist; tkp->name != NULL; ++tkp) {
105                 if ((t = tigetstr(tkp->ts)) == NULL || t == (char *)-1)
106                         continue;
107                 for (kp = keylist;; ++kp)
108                         if (kp->value == tkp->value)
109                                 break;
110                 if (kp == NULL)
111                         continue;
112                 if (seq_set(sp, tkp->name, strlen(tkp->name), t, strlen(t),
113                     &kp->ch, 1, SEQ_INPUT, SEQ_NOOVERWRITE | SEQ_SCREEN))
114                         return (1);
115         }
116
117         /* Input mappings that are already set or are text deletions. */
118         for (tkp = m2_tklist; tkp->name != NULL; ++tkp) {
119                 if ((t = tigetstr(tkp->ts)) == NULL || t == (char *)-1)
120                         continue;
121                 /*
122                  * !!!
123                  * Some terminals' <cursor_left> keys send single <backspace>
124                  * characters.  This is okay in command mapping, but not okay
125                  * in input mapping.  That combination is the only one we'll
126                  * ever see, hopefully, so kluge it here for now.
127                  */
128                 if (!strcmp(t, "\b"))
129                         continue;
130                 if (tkp->output == NULL) {
131                         if (seq_set(sp, tkp->name, strlen(tkp->name),
132                             t, strlen(t), NULL, 0,
133                             SEQ_INPUT, SEQ_NOOVERWRITE | SEQ_SCREEN))
134                                 return (1);
135                 } else
136                         if (seq_set(sp, tkp->name, strlen(tkp->name),
137                             t, strlen(t), tkp->output, strlen(tkp->output),
138                             SEQ_INPUT, SEQ_NOOVERWRITE | SEQ_SCREEN))
139                                 return (1);
140         }
141
142         /*
143          * Rework any function key mappings that were set before the
144          * screen was initialized.
145          */
146         for (qp = sp->gp->seqq.lh_first; qp != NULL; qp = qp->q.le_next)
147                 if (F_ISSET(qp, SEQ_FUNCMAP))
148                         (void)cl_pfmap(sp, qp->stype,
149                             qp->input, qp->ilen, qp->output, qp->olen);
150         return (0);
151 }
152
153 /*
154  * cl_term_end --
155  *      End the special keys defined by the termcap/terminfo entry.
156  *
157  * PUBLIC: int cl_term_end __P((GS *));
158  */
159 int
160 cl_term_end(gp)
161         GS *gp;
162 {
163         SEQ *qp, *nqp;
164
165         /* Delete screen specific mappings. */
166         for (qp = gp->seqq.lh_first; qp != NULL; qp = nqp) {
167                 nqp = qp->q.le_next;
168                 if (F_ISSET(qp, SEQ_SCREEN))
169                         (void)seq_mdel(qp);
170         }
171         return (0);
172 }
173
174 /*
175  * cl_fmap --
176  *      Map a function key.
177  *
178  * PUBLIC: int cl_fmap __P((SCR *, seq_t, CHAR_T *, size_t, CHAR_T *, size_t));
179  */
180 int
181 cl_fmap(sp, stype, from, flen, to, tlen)
182         SCR *sp;
183         seq_t stype;
184         CHAR_T *from, *to;
185         size_t flen, tlen;
186 {
187         /* Ignore until the screen is running, do the real work then. */
188         if (F_ISSET(sp, SC_VI) && !F_ISSET(sp, SC_SCR_VI))
189                 return (0);
190         if (F_ISSET(sp, SC_EX) && !F_ISSET(sp, SC_SCR_EX))
191                 return (0);
192
193         return (cl_pfmap(sp, stype, from, flen, to, tlen));
194 }
195
196 /*
197  * cl_pfmap --
198  *      Map a function key (private version).
199  */
200 static int
201 cl_pfmap(sp, stype, from, flen, to, tlen)
202         SCR *sp;
203         seq_t stype;
204         CHAR_T *from, *to;
205         size_t flen, tlen;
206 {
207         size_t nlen;
208         char *p, keyname[64];
209
210         (void)snprintf(keyname, sizeof(keyname), "kf%d", atoi(from + 1));
211         if ((p = tigetstr(keyname)) == NULL ||
212             p == (char *)-1 || strlen(p) == 0)
213                 p = NULL;
214         if (p == NULL) {
215                 msgq_str(sp, M_ERR, from, "233|This terminal has no %s key");
216                 return (1);
217         }
218
219         nlen = snprintf(keyname,
220             sizeof(keyname), "function key %d", atoi(from + 1));
221         return (seq_set(sp, keyname, nlen,
222             p, strlen(p), to, tlen, stype, SEQ_NOOVERWRITE | SEQ_SCREEN));
223 }
224
225 /*
226  * cl_optchange --
227  *      Curses screen specific "option changed" routine.
228  *
229  * PUBLIC: int cl_optchange __P((SCR *, int, char *, u_long *));
230  */
231 int
232 cl_optchange(sp, opt, str, valp)
233         SCR *sp;
234         int opt;
235         char *str;
236         u_long *valp;
237 {
238         CL_PRIVATE *clp;
239
240         clp = CLP(sp);
241
242         switch (opt) {
243         case O_COLUMNS:
244         case O_LINES:
245         case O_TERM:
246                 /*
247                  * Changing the columns, lines or terminal require that
248                  * we restart the screen.
249                  */
250                 F_SET(sp->gp, G_SRESTART);
251                 F_CLR(sp, SC_SCR_EX | SC_SCR_VI);
252                 break;
253         case O_MESG:
254                 (void)cl_omesg(sp, clp, !*valp);
255                 break;
256         case O_WINDOWNAME:
257                 if (*valp) {
258                         F_CLR(clp, CL_RENAME_OK);
259
260                         (void)cl_rename(sp, NULL, 0);
261                 } else {
262                         F_SET(clp, CL_RENAME_OK);
263
264                         /*
265                          * If the screen is live, i.e. we're not reading the
266                          * .exrc file, update the window.
267                          */
268                         if (sp->frp != NULL && sp->frp->name != NULL)
269                                 (void)cl_rename(sp, sp->frp->name, 1);
270                 }
271                 break;
272         }
273         return (0);
274 }
275
276 /*
277  * cl_omesg --
278  *      Turn the tty write permission on or off.
279  *
280  * PUBLIC: int cl_omesg __P((SCR *, CL_PRIVATE *, int));
281  */
282 int
283 cl_omesg(sp, clp, on)
284         SCR *sp;
285         CL_PRIVATE *clp;
286         int on;
287 {
288         struct stat sb;
289         char *tty;
290
291         /* Find the tty, get the current permissions. */
292         if ((tty = ttyname(STDERR_FILENO)) == NULL) {
293                 if (sp != NULL)
294                         msgq(sp, M_SYSERR, "stderr");
295                 return (1);
296         }
297         if (stat(tty, &sb) < 0) {
298                 if (sp != NULL)
299                         msgq(sp, M_SYSERR, "%s", tty);
300                 return (1);
301         }
302
303         /* Save the original status if it's unknown. */
304         if (clp->tgw == TGW_UNKNOWN)
305                 clp->tgw = sb.st_mode & S_IWGRP ? TGW_SET : TGW_UNSET;
306
307         /* Toggle the permissions. */
308         if (on) {
309                 if (chmod(tty, sb.st_mode | S_IWGRP) < 0) {
310                         if (sp != NULL)
311                                 msgq(sp, M_SYSERR,
312                                     "046|messages not turned on: %s", tty);
313                         return (1);
314                 }
315         } else
316                 if (chmod(tty, sb.st_mode & ~S_IWGRP) < 0) {
317                         if (sp != NULL)
318                                 msgq(sp, M_SYSERR,
319                                     "045|messages not turned off: %s", tty);
320                         return (1);
321                 }
322         return (0);
323 }
324
325 /*
326  * cl_ssize --
327  *      Return the terminal size.
328  *
329  * PUBLIC: int cl_ssize __P((SCR *, int, size_t *, size_t *, int *));
330  */
331 int
332 cl_ssize(sp, sigwinch, rowp, colp, changedp)
333         SCR *sp;
334         int sigwinch;
335         size_t *rowp, *colp;
336         int *changedp;
337 {
338 #ifdef TIOCGWINSZ
339         struct winsize win;
340 #endif
341         size_t col, row;
342         int rval;
343         char *p;
344
345         /* Assume it's changed. */
346         if (changedp != NULL)
347                 *changedp = 1;
348
349         /*
350          * !!!
351          * sp may be NULL.
352          *
353          * Get the screen rows and columns.  If the values are wrong, it's
354          * not a big deal -- as soon as the user sets them explicitly the
355          * environment will be set and the screen package will use the new
356          * values.
357          *
358          * Try TIOCGWINSZ.
359          */
360         row = col = 0;
361 #ifdef TIOCGWINSZ
362         if (ioctl(STDERR_FILENO, TIOCGWINSZ, &win) != -1) {
363                 row = win.ws_row;
364                 col = win.ws_col;
365         }
366 #endif
367         /* If here because of suspend or a signal, only trust TIOCGWINSZ. */
368         if (sigwinch) {
369                 /*
370                  * Somebody didn't get TIOCGWINSZ right, or has suspend
371                  * without window resizing support.  The user just lost,
372                  * but there's nothing we can do.
373                  */
374                 if (row == 0 || col == 0) {
375                         if (changedp != NULL)
376                                 *changedp = 0;
377                         return (0);
378                 }
379
380                 /*
381                  * SunOS systems deliver SIGWINCH when windows are uncovered
382                  * as well as when they change size.  In addition, we call
383                  * here when continuing after being suspended since the window
384                  * may have changed size.  Since we don't want to background
385                  * all of the screens just because the window was uncovered,
386                  * ignore the signal if there's no change.
387                  */
388                 if (sp != NULL &&
389                     row == O_VAL(sp, O_LINES) && col == O_VAL(sp, O_COLUMNS)) {
390                         if (changedp != NULL)
391                                 *changedp = 0;
392                         return (0);
393                 }
394
395                 if (rowp != NULL)
396                         *rowp = row;
397                 if (colp != NULL)
398                         *colp = col;
399                 return (0);
400         }
401
402         /*
403          * !!!
404          * If TIOCGWINSZ failed, or had entries of 0, try termcap.  This
405          * routine is called before any termcap or terminal information
406          * has been set up.  If there's no TERM environmental variable set,
407          * let it go, at least ex can run.
408          */
409         if (row == 0 || col == 0) {
410                 if ((p = getenv("TERM")) == NULL)
411                         goto noterm;
412                 if (row == 0)
413                         if ((rval = tigetnum("lines")) < 0)
414                                 msgq(sp, M_SYSERR, "tigetnum: lines");
415                         else
416                                 row = rval;
417                 if (col == 0)
418                         if ((rval = tigetnum("cols")) < 0)
419                                 msgq(sp, M_SYSERR, "tigetnum: cols");
420                         else
421                                 col = rval;
422         }
423
424         /* If nothing else, well, it's probably a VT100. */
425 noterm: if (row == 0)
426                 row = 24;
427         if (col == 0)
428                 col = 80;
429
430         /*
431          * !!!
432          * POSIX 1003.2 requires the environment to override everything.
433          * Often, people can get nvi to stop messing up their screen by
434          * deleting the LINES and COLUMNS environment variables from their
435          * dot-files.
436          */
437         if ((p = getenv("LINES")) != NULL)
438                 row = strtol(p, NULL, 10);
439         if ((p = getenv("COLUMNS")) != NULL)
440                 col = strtol(p, NULL, 10);
441
442         if (rowp != NULL)
443                 *rowp = row;
444         if (colp != NULL)
445                 *colp = col;
446         return (0);
447 }
448
449 /*
450  * cl_putchar --
451  *      Function version of putchar, for tputs.
452  *
453  * PUBLIC: int cl_putchar __P((int));
454  */
455 int
456 cl_putchar(ch)
457         int ch;
458 {
459         return (putchar(ch));
460 }