| 1 |
/* $NetBSD: tty.c,v 1.65 2016/05/09 21:46:56 christos Exp $ */ |
| 2 |
|
| 3 |
/*- |
| 4 |
* Copyright (c) 1992, 1993 |
| 5 |
* The Regents of the University of California. All rights reserved. |
| 6 |
* |
| 7 |
* This code is derived from software contributed to Berkeley by |
| 8 |
* Christos Zoulas of Cornell University. |
| 9 |
* |
| 10 |
* Redistribution and use in source and binary forms, with or without |
| 11 |
* modification, are permitted provided that the following conditions |
| 12 |
* are met: |
| 13 |
* 1. Redistributions of source code must retain the above copyright |
| 14 |
* notice, this list of conditions and the following disclaimer. |
| 15 |
* 2. Redistributions in binary form must reproduce the above copyright |
| 16 |
* notice, this list of conditions and the following disclaimer in the |
| 17 |
* documentation and/or other materials provided with the distribution. |
| 18 |
* 3. Neither the name of the University nor the names of its contributors |
| 19 |
* may be used to endorse or promote products derived from this software |
| 20 |
* without specific prior written permission. |
| 21 |
* |
| 22 |
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
| 23 |
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| 24 |
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| 25 |
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
| 26 |
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| 27 |
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| 28 |
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| 29 |
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| 30 |
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| 31 |
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| 32 |
* SUCH DAMAGE. |
| 33 |
*/ |
| 34 |
|
| 35 |
#include "config.h" |
| 36 |
#if !defined(lint) && !defined(SCCSID) |
| 37 |
#if 0 |
| 38 |
static char sccsid[] = "@(#)tty.c 8.1 (Berkeley) 6/4/93"; |
| 39 |
#else |
| 40 |
__RCSID("$NetBSD: tty.c,v 1.65 2016/05/09 21:46:56 christos Exp $"); |
| 41 |
#endif |
| 42 |
#endif /* not lint && not SCCSID */ |
| 43 |
|
| 44 |
/* |
| 45 |
* tty.c: tty interface stuff |
| 46 |
*/ |
| 47 |
#include <assert.h> |
| 48 |
#include <errno.h> |
| 49 |
#include <stdlib.h> /* for abort */ |
| 50 |
#include <string.h> |
| 51 |
#include <strings.h> /* for ffs */ |
| 52 |
#include <unistd.h> /* for isatty */ |
| 53 |
|
| 54 |
#include "el.h" |
| 55 |
#include "fcns.h" |
| 56 |
#include "parse.h" |
| 57 |
|
| 58 |
typedef struct ttymodes_t { |
| 59 |
const char *m_name; |
| 60 |
unsigned int m_value; |
| 61 |
int m_type; |
| 62 |
} ttymodes_t; |
| 63 |
|
| 64 |
typedef struct ttymap_t { |
| 65 |
wint_t nch, och; /* Internal and termio rep of chars */ |
| 66 |
el_action_t bind[3]; /* emacs, vi, and vi-cmd */ |
| 67 |
} ttymap_t; |
| 68 |
|
| 69 |
|
| 70 |
static const ttyperm_t ttyperm = { |
| 71 |
{ |
| 72 |
{"iflag:", ICRNL, (INLCR | IGNCR)}, |
| 73 |
{"oflag:", (OPOST | ONLCR), ONLRET}, |
| 74 |
{"cflag:", 0, 0}, |
| 75 |
{"lflag:", (ISIG | ICANON | ECHO | ECHOE | ECHOCTL | IEXTEN), |
| 76 |
(NOFLSH | ECHONL | EXTPROC | FLUSHO)}, |
| 77 |
{"chars:", 0, 0}, |
| 78 |
}, |
| 79 |
{ |
| 80 |
{"iflag:", (INLCR | ICRNL), IGNCR}, |
| 81 |
{"oflag:", (OPOST | ONLCR), ONLRET}, |
| 82 |
{"cflag:", 0, 0}, |
| 83 |
{"lflag:", ISIG, |
| 84 |
(NOFLSH | ICANON | ECHO | ECHOK | ECHONL | EXTPROC | IEXTEN | FLUSHO)}, |
| 85 |
{"chars:", (C_SH(C_MIN) | C_SH(C_TIME) | C_SH(C_SWTCH) | C_SH(C_DSWTCH) | |
| 86 |
C_SH(C_SUSP) | C_SH(C_DSUSP) | C_SH(C_EOL) | C_SH(C_DISCARD) | |
| 87 |
C_SH(C_PGOFF) | C_SH(C_PAGE) | C_SH(C_STATUS)), 0} |
| 88 |
}, |
| 89 |
{ |
| 90 |
{"iflag:", 0, IXON | IXOFF | INLCR | ICRNL}, |
| 91 |
{"oflag:", 0, 0}, |
| 92 |
{"cflag:", 0, 0}, |
| 93 |
{"lflag:", 0, ISIG | IEXTEN}, |
| 94 |
{"chars:", 0, 0}, |
| 95 |
} |
| 96 |
}; |
| 97 |
|
| 98 |
static const ttychar_t ttychar = { |
| 99 |
{ |
| 100 |
CINTR, CQUIT, CERASE, CKILL, |
| 101 |
CEOF, CEOL, CEOL2, CSWTCH, |
| 102 |
CDSWTCH, CERASE2, CSTART, CSTOP, |
| 103 |
CWERASE, CSUSP, CDSUSP, CREPRINT, |
| 104 |
CDISCARD, CLNEXT, CSTATUS, CPAGE, |
| 105 |
CPGOFF, CKILL2, CBRK, CMIN, |
| 106 |
CTIME |
| 107 |
}, |
| 108 |
{ |
| 109 |
CINTR, CQUIT, CERASE, CKILL, |
| 110 |
_POSIX_VDISABLE, _POSIX_VDISABLE, _POSIX_VDISABLE, _POSIX_VDISABLE, |
| 111 |
_POSIX_VDISABLE, CERASE2, CSTART, CSTOP, |
| 112 |
_POSIX_VDISABLE, CSUSP, _POSIX_VDISABLE, _POSIX_VDISABLE, |
| 113 |
CDISCARD, _POSIX_VDISABLE, _POSIX_VDISABLE, _POSIX_VDISABLE, |
| 114 |
_POSIX_VDISABLE, _POSIX_VDISABLE, _POSIX_VDISABLE, 1, |
| 115 |
0 |
| 116 |
}, |
| 117 |
{ |
| 118 |
0, 0, 0, 0, |
| 119 |
0, 0, 0, 0, |
| 120 |
0, 0, 0, 0, |
| 121 |
0, 0, 0, 0, |
| 122 |
0, 0, 0, 0, |
| 123 |
0, 0, 0, 0, |
| 124 |
0 |
| 125 |
} |
| 126 |
}; |
| 127 |
|
| 128 |
static const ttymap_t tty_map[] = { |
| 129 |
#ifdef VERASE |
| 130 |
{C_ERASE, VERASE, |
| 131 |
{EM_DELETE_PREV_CHAR, VI_DELETE_PREV_CHAR, ED_PREV_CHAR}}, |
| 132 |
#endif /* VERASE */ |
| 133 |
#ifdef VERASE2 |
| 134 |
{C_ERASE2, VERASE2, |
| 135 |
{EM_DELETE_PREV_CHAR, VI_DELETE_PREV_CHAR, ED_PREV_CHAR}}, |
| 136 |
#endif /* VERASE2 */ |
| 137 |
#ifdef VKILL |
| 138 |
{C_KILL, VKILL, |
| 139 |
{EM_KILL_LINE, VI_KILL_LINE_PREV, ED_UNASSIGNED}}, |
| 140 |
#endif /* VKILL */ |
| 141 |
#ifdef VKILL2 |
| 142 |
{C_KILL2, VKILL2, |
| 143 |
{EM_KILL_LINE, VI_KILL_LINE_PREV, ED_UNASSIGNED}}, |
| 144 |
#endif /* VKILL2 */ |
| 145 |
#ifdef VEOF |
| 146 |
{C_EOF, VEOF, |
| 147 |
{EM_DELETE_OR_LIST, VI_LIST_OR_EOF, ED_UNASSIGNED}}, |
| 148 |
#endif /* VEOF */ |
| 149 |
#ifdef VWERASE |
| 150 |
{C_WERASE, VWERASE, |
| 151 |
{ED_DELETE_PREV_WORD, ED_DELETE_PREV_WORD, ED_PREV_WORD}}, |
| 152 |
#endif /* VWERASE */ |
| 153 |
#ifdef VREPRINT |
| 154 |
{C_REPRINT, VREPRINT, |
| 155 |
{ED_REDISPLAY, ED_INSERT, ED_REDISPLAY}}, |
| 156 |
#endif /* VREPRINT */ |
| 157 |
#ifdef VLNEXT |
| 158 |
{C_LNEXT, VLNEXT, |
| 159 |
{ED_QUOTED_INSERT, ED_QUOTED_INSERT, ED_UNASSIGNED}}, |
| 160 |
#endif /* VLNEXT */ |
| 161 |
{(wint_t)-1, (wint_t)-1, |
| 162 |
{ED_UNASSIGNED, ED_UNASSIGNED, ED_UNASSIGNED}} |
| 163 |
}; |
| 164 |
|
| 165 |
static const ttymodes_t ttymodes[] = { |
| 166 |
#ifdef IGNBRK |
| 167 |
{"ignbrk", IGNBRK, MD_INP}, |
| 168 |
#endif /* IGNBRK */ |
| 169 |
#ifdef BRKINT |
| 170 |
{"brkint", BRKINT, MD_INP}, |
| 171 |
#endif /* BRKINT */ |
| 172 |
#ifdef IGNPAR |
| 173 |
{"ignpar", IGNPAR, MD_INP}, |
| 174 |
#endif /* IGNPAR */ |
| 175 |
#ifdef PARMRK |
| 176 |
{"parmrk", PARMRK, MD_INP}, |
| 177 |
#endif /* PARMRK */ |
| 178 |
#ifdef INPCK |
| 179 |
{"inpck", INPCK, MD_INP}, |
| 180 |
#endif /* INPCK */ |
| 181 |
#ifdef ISTRIP |
| 182 |
{"istrip", ISTRIP, MD_INP}, |
| 183 |
#endif /* ISTRIP */ |
| 184 |
#ifdef INLCR |
| 185 |
{"inlcr", INLCR, MD_INP}, |
| 186 |
#endif /* INLCR */ |
| 187 |
#ifdef IGNCR |
| 188 |
{"igncr", IGNCR, MD_INP}, |
| 189 |
#endif /* IGNCR */ |
| 190 |
#ifdef ICRNL |
| 191 |
{"icrnl", ICRNL, MD_INP}, |
| 192 |
#endif /* ICRNL */ |
| 193 |
#ifdef IUCLC |
| 194 |
{"iuclc", IUCLC, MD_INP}, |
| 195 |
#endif /* IUCLC */ |
| 196 |
#ifdef IXON |
| 197 |
{"ixon", IXON, MD_INP}, |
| 198 |
#endif /* IXON */ |
| 199 |
#ifdef IXANY |
| 200 |
{"ixany", IXANY, MD_INP}, |
| 201 |
#endif /* IXANY */ |
| 202 |
#ifdef IXOFF |
| 203 |
{"ixoff", IXOFF, MD_INP}, |
| 204 |
#endif /* IXOFF */ |
| 205 |
#ifdef IMAXBEL |
| 206 |
{"imaxbel", IMAXBEL, MD_INP}, |
| 207 |
#endif /* IMAXBEL */ |
| 208 |
|
| 209 |
#ifdef OPOST |
| 210 |
{"opost", OPOST, MD_OUT}, |
| 211 |
#endif /* OPOST */ |
| 212 |
#ifdef OLCUC |
| 213 |
{"olcuc", OLCUC, MD_OUT}, |
| 214 |
#endif /* OLCUC */ |
| 215 |
#ifdef ONLCR |
| 216 |
{"onlcr", ONLCR, MD_OUT}, |
| 217 |
#endif /* ONLCR */ |
| 218 |
#ifdef OCRNL |
| 219 |
{"ocrnl", OCRNL, MD_OUT}, |
| 220 |
#endif /* OCRNL */ |
| 221 |
#ifdef ONOCR |
| 222 |
{"onocr", ONOCR, MD_OUT}, |
| 223 |
#endif /* ONOCR */ |
| 224 |
#ifdef ONOEOT |
| 225 |
{"onoeot", ONOEOT, MD_OUT}, |
| 226 |
#endif /* ONOEOT */ |
| 227 |
#ifdef ONLRET |
| 228 |
{"onlret", ONLRET, MD_OUT}, |
| 229 |
#endif /* ONLRET */ |
| 230 |
#ifdef OFILL |
| 231 |
{"ofill", OFILL, MD_OUT}, |
| 232 |
#endif /* OFILL */ |
| 233 |
#ifdef OFDEL |
| 234 |
{"ofdel", OFDEL, MD_OUT}, |
| 235 |
#endif /* OFDEL */ |
| 236 |
#ifdef NLDLY |
| 237 |
{"nldly", NLDLY, MD_OUT}, |
| 238 |
#endif /* NLDLY */ |
| 239 |
#ifdef CRDLY |
| 240 |
{"crdly", CRDLY, MD_OUT}, |
| 241 |
#endif /* CRDLY */ |
| 242 |
#ifdef TABDLY |
| 243 |
{"tabdly", TABDLY, MD_OUT}, |
| 244 |
#endif /* TABDLY */ |
| 245 |
#ifdef XTABS |
| 246 |
{"xtabs", XTABS, MD_OUT}, |
| 247 |
#endif /* XTABS */ |
| 248 |
#ifdef BSDLY |
| 249 |
{"bsdly", BSDLY, MD_OUT}, |
| 250 |
#endif /* BSDLY */ |
| 251 |
#ifdef VTDLY |
| 252 |
{"vtdly", VTDLY, MD_OUT}, |
| 253 |
#endif /* VTDLY */ |
| 254 |
#ifdef FFDLY |
| 255 |
{"ffdly", FFDLY, MD_OUT}, |
| 256 |
#endif /* FFDLY */ |
| 257 |
#ifdef PAGEOUT |
| 258 |
{"pageout", PAGEOUT, MD_OUT}, |
| 259 |
#endif /* PAGEOUT */ |
| 260 |
#ifdef WRAP |
| 261 |
{"wrap", WRAP, MD_OUT}, |
| 262 |
#endif /* WRAP */ |
| 263 |
|
| 264 |
#ifdef CIGNORE |
| 265 |
{"cignore", CIGNORE, MD_CTL}, |
| 266 |
#endif /* CBAUD */ |
| 267 |
#ifdef CBAUD |
| 268 |
{"cbaud", CBAUD, MD_CTL}, |
| 269 |
#endif /* CBAUD */ |
| 270 |
#ifdef CSTOPB |
| 271 |
{"cstopb", CSTOPB, MD_CTL}, |
| 272 |
#endif /* CSTOPB */ |
| 273 |
#ifdef CREAD |
| 274 |
{"cread", CREAD, MD_CTL}, |
| 275 |
#endif /* CREAD */ |
| 276 |
#ifdef PARENB |
| 277 |
{"parenb", PARENB, MD_CTL}, |
| 278 |
#endif /* PARENB */ |
| 279 |
#ifdef PARODD |
| 280 |
{"parodd", PARODD, MD_CTL}, |
| 281 |
#endif /* PARODD */ |
| 282 |
#ifdef HUPCL |
| 283 |
{"hupcl", HUPCL, MD_CTL}, |
| 284 |
#endif /* HUPCL */ |
| 285 |
#ifdef CLOCAL |
| 286 |
{"clocal", CLOCAL, MD_CTL}, |
| 287 |
#endif /* CLOCAL */ |
| 288 |
#ifdef LOBLK |
| 289 |
{"loblk", LOBLK, MD_CTL}, |
| 290 |
#endif /* LOBLK */ |
| 291 |
#ifdef CIBAUD |
| 292 |
{"cibaud", CIBAUD, MD_CTL}, |
| 293 |
#endif /* CIBAUD */ |
| 294 |
#ifdef CRTSCTS |
| 295 |
#ifdef CCTS_OFLOW |
| 296 |
{"ccts_oflow", CCTS_OFLOW, MD_CTL}, |
| 297 |
#else |
| 298 |
{"crtscts", CRTSCTS, MD_CTL}, |
| 299 |
#endif /* CCTS_OFLOW */ |
| 300 |
#endif /* CRTSCTS */ |
| 301 |
#ifdef CRTS_IFLOW |
| 302 |
{"crts_iflow", CRTS_IFLOW, MD_CTL}, |
| 303 |
#endif /* CRTS_IFLOW */ |
| 304 |
#ifdef CDTRCTS |
| 305 |
{"cdtrcts", CDTRCTS, MD_CTL}, |
| 306 |
#endif /* CDTRCTS */ |
| 307 |
#ifdef MDMBUF |
| 308 |
{"mdmbuf", MDMBUF, MD_CTL}, |
| 309 |
#endif /* MDMBUF */ |
| 310 |
#ifdef RCV1EN |
| 311 |
{"rcv1en", RCV1EN, MD_CTL}, |
| 312 |
#endif /* RCV1EN */ |
| 313 |
#ifdef XMT1EN |
| 314 |
{"xmt1en", XMT1EN, MD_CTL}, |
| 315 |
#endif /* XMT1EN */ |
| 316 |
|
| 317 |
#ifdef ISIG |
| 318 |
{"isig", ISIG, MD_LIN}, |
| 319 |
#endif /* ISIG */ |
| 320 |
#ifdef ICANON |
| 321 |
{"icanon", ICANON, MD_LIN}, |
| 322 |
#endif /* ICANON */ |
| 323 |
#ifdef XCASE |
| 324 |
{"xcase", XCASE, MD_LIN}, |
| 325 |
#endif /* XCASE */ |
| 326 |
#ifdef ECHO |
| 327 |
{"echo", ECHO, MD_LIN}, |
| 328 |
#endif /* ECHO */ |
| 329 |
#ifdef ECHOE |
| 330 |
{"echoe", ECHOE, MD_LIN}, |
| 331 |
#endif /* ECHOE */ |
| 332 |
#ifdef ECHOK |
| 333 |
{"echok", ECHOK, MD_LIN}, |
| 334 |
#endif /* ECHOK */ |
| 335 |
#ifdef ECHONL |
| 336 |
{"echonl", ECHONL, MD_LIN}, |
| 337 |
#endif /* ECHONL */ |
| 338 |
#ifdef NOFLSH |
| 339 |
{"noflsh", NOFLSH, MD_LIN}, |
| 340 |
#endif /* NOFLSH */ |
| 341 |
#ifdef TOSTOP |
| 342 |
{"tostop", TOSTOP, MD_LIN}, |
| 343 |
#endif /* TOSTOP */ |
| 344 |
#ifdef ECHOCTL |
| 345 |
{"echoctl", ECHOCTL, MD_LIN}, |
| 346 |
#endif /* ECHOCTL */ |
| 347 |
#ifdef ECHOPRT |
| 348 |
{"echoprt", ECHOPRT, MD_LIN}, |
| 349 |
#endif /* ECHOPRT */ |
| 350 |
#ifdef ECHOKE |
| 351 |
{"echoke", ECHOKE, MD_LIN}, |
| 352 |
#endif /* ECHOKE */ |
| 353 |
#ifdef DEFECHO |
| 354 |
{"defecho", DEFECHO, MD_LIN}, |
| 355 |
#endif /* DEFECHO */ |
| 356 |
#ifdef FLUSHO |
| 357 |
{"flusho", FLUSHO, MD_LIN}, |
| 358 |
#endif /* FLUSHO */ |
| 359 |
#ifdef PENDIN |
| 360 |
{"pendin", PENDIN, MD_LIN}, |
| 361 |
#endif /* PENDIN */ |
| 362 |
#ifdef IEXTEN |
| 363 |
{"iexten", IEXTEN, MD_LIN}, |
| 364 |
#endif /* IEXTEN */ |
| 365 |
#ifdef NOKERNINFO |
| 366 |
{"nokerninfo", NOKERNINFO, MD_LIN}, |
| 367 |
#endif /* NOKERNINFO */ |
| 368 |
#ifdef ALTWERASE |
| 369 |
{"altwerase", ALTWERASE, MD_LIN}, |
| 370 |
#endif /* ALTWERASE */ |
| 371 |
#ifdef EXTPROC |
| 372 |
{"extproc", EXTPROC, MD_LIN}, |
| 373 |
#endif /* EXTPROC */ |
| 374 |
|
| 375 |
#if defined(VINTR) |
| 376 |
{"intr", C_SH(C_INTR), MD_CHAR}, |
| 377 |
#endif /* VINTR */ |
| 378 |
#if defined(VQUIT) |
| 379 |
{"quit", C_SH(C_QUIT), MD_CHAR}, |
| 380 |
#endif /* VQUIT */ |
| 381 |
#if defined(VERASE) |
| 382 |
{"erase", C_SH(C_ERASE), MD_CHAR}, |
| 383 |
#endif /* VERASE */ |
| 384 |
#if defined(VKILL) |
| 385 |
{"kill", C_SH(C_KILL), MD_CHAR}, |
| 386 |
#endif /* VKILL */ |
| 387 |
#if defined(VEOF) |
| 388 |
{"eof", C_SH(C_EOF), MD_CHAR}, |
| 389 |
#endif /* VEOF */ |
| 390 |
#if defined(VEOL) |
| 391 |
{"eol", C_SH(C_EOL), MD_CHAR}, |
| 392 |
#endif /* VEOL */ |
| 393 |
#if defined(VEOL2) |
| 394 |
{"eol2", C_SH(C_EOL2), MD_CHAR}, |
| 395 |
#endif /* VEOL2 */ |
| 396 |
#if defined(VSWTCH) |
| 397 |
{"swtch", C_SH(C_SWTCH), MD_CHAR}, |
| 398 |
#endif /* VSWTCH */ |
| 399 |
#if defined(VDSWTCH) |
| 400 |
{"dswtch", C_SH(C_DSWTCH), MD_CHAR}, |
| 401 |
#endif /* VDSWTCH */ |
| 402 |
#if defined(VERASE2) |
| 403 |
{"erase2", C_SH(C_ERASE2), MD_CHAR}, |
| 404 |
#endif /* VERASE2 */ |
| 405 |
#if defined(VSTART) |
| 406 |
{"start", C_SH(C_START), MD_CHAR}, |
| 407 |
#endif /* VSTART */ |
| 408 |
#if defined(VSTOP) |
| 409 |
{"stop", C_SH(C_STOP), MD_CHAR}, |
| 410 |
#endif /* VSTOP */ |
| 411 |
#if defined(VWERASE) |
| 412 |
{"werase", C_SH(C_WERASE), MD_CHAR}, |
| 413 |
#endif /* VWERASE */ |
| 414 |
#if defined(VSUSP) |
| 415 |
{"susp", C_SH(C_SUSP), MD_CHAR}, |
| 416 |
#endif /* VSUSP */ |
| 417 |
#if defined(VDSUSP) |
| 418 |
{"dsusp", C_SH(C_DSUSP), MD_CHAR}, |
| 419 |
#endif /* VDSUSP */ |
| 420 |
#if defined(VREPRINT) |
| 421 |
{"reprint", C_SH(C_REPRINT), MD_CHAR}, |
| 422 |
#endif /* VREPRINT */ |
| 423 |
#if defined(VDISCARD) |
| 424 |
{"discard", C_SH(C_DISCARD), MD_CHAR}, |
| 425 |
#endif /* VDISCARD */ |
| 426 |
#if defined(VLNEXT) |
| 427 |
{"lnext", C_SH(C_LNEXT), MD_CHAR}, |
| 428 |
#endif /* VLNEXT */ |
| 429 |
#if defined(VSTATUS) |
| 430 |
{"status", C_SH(C_STATUS), MD_CHAR}, |
| 431 |
#endif /* VSTATUS */ |
| 432 |
#if defined(VPAGE) |
| 433 |
{"page", C_SH(C_PAGE), MD_CHAR}, |
| 434 |
#endif /* VPAGE */ |
| 435 |
#if defined(VPGOFF) |
| 436 |
{"pgoff", C_SH(C_PGOFF), MD_CHAR}, |
| 437 |
#endif /* VPGOFF */ |
| 438 |
#if defined(VKILL2) |
| 439 |
{"kill2", C_SH(C_KILL2), MD_CHAR}, |
| 440 |
#endif /* VKILL2 */ |
| 441 |
#if defined(VBRK) |
| 442 |
{"brk", C_SH(C_BRK), MD_CHAR}, |
| 443 |
#endif /* VBRK */ |
| 444 |
#if defined(VMIN) |
| 445 |
{"min", C_SH(C_MIN), MD_CHAR}, |
| 446 |
#endif /* VMIN */ |
| 447 |
#if defined(VTIME) |
| 448 |
{"time", C_SH(C_TIME), MD_CHAR}, |
| 449 |
#endif /* VTIME */ |
| 450 |
{NULL, 0, -1}, |
| 451 |
}; |
| 452 |
|
| 453 |
|
| 454 |
|
| 455 |
#define tty__gettabs(td) ((((td)->c_oflag & TAB3) == TAB3) ? 0 : 1) |
| 456 |
#define tty__geteightbit(td) (((td)->c_cflag & CSIZE) == CS8) |
| 457 |
#define tty__cooked_mode(td) ((td)->c_lflag & ICANON) |
| 458 |
|
| 459 |
static int tty_getty(EditLine *, struct termios *); |
| 460 |
static int tty_setty(EditLine *, int, const struct termios *); |
| 461 |
static int tty__getcharindex(int); |
| 462 |
static void tty__getchar(struct termios *, unsigned char *); |
| 463 |
static void tty__setchar(struct termios *, unsigned char *); |
| 464 |
static speed_t tty__getspeed(struct termios *); |
| 465 |
static int tty_setup(EditLine *); |
| 466 |
static void tty_setup_flags(EditLine *, struct termios *, int); |
| 467 |
|
| 468 |
#define t_qu t_ts |
| 469 |
|
| 470 |
/* tty_getty(): |
| 471 |
* Wrapper for tcgetattr to handle EINTR |
| 472 |
*/ |
| 473 |
static int |
| 474 |
tty_getty(EditLine *el, struct termios *t) |
| 475 |
{ |
| 476 |
int rv; |
| 477 |
while ((rv = tcgetattr(el->el_infd, t)) == -1 && errno == EINTR) |
| 478 |
continue; |
| 479 |
return rv; |
| 480 |
} |
| 481 |
|
| 482 |
/* tty_setty(): |
| 483 |
* Wrapper for tcsetattr to handle EINTR |
| 484 |
*/ |
| 485 |
static int |
| 486 |
tty_setty(EditLine *el, int action, const struct termios *t) |
| 487 |
{ |
| 488 |
int rv; |
| 489 |
while ((rv = tcsetattr(el->el_infd, action, t)) == -1 && errno == EINTR) |
| 490 |
continue; |
| 491 |
return rv; |
| 492 |
} |
| 493 |
|
| 494 |
/* tty_setup(): |
| 495 |
* Get the tty parameters and initialize the editing state |
| 496 |
*/ |
| 497 |
static int |
| 498 |
tty_setup(EditLine *el) |
| 499 |
{ |
| 500 |
int rst = 1; |
| 501 |
|
| 502 |
if (el->el_flags & EDIT_DISABLED) |
| 503 |
return 0; |
| 504 |
|
| 505 |
if (el->el_tty.t_initialized) |
| 506 |
return -1; |
| 507 |
|
| 508 |
if (!isatty(el->el_outfd)) { |
| 509 |
#ifdef DEBUG_TTY |
| 510 |
(void) fprintf(el->el_errfile, "%s: isatty: %s\n", __func__, |
| 511 |
strerror(errno)); |
| 512 |
#endif /* DEBUG_TTY */ |
| 513 |
return -1; |
| 514 |
} |
| 515 |
if (tty_getty(el, &el->el_tty.t_or) == -1) { |
| 516 |
#ifdef DEBUG_TTY |
| 517 |
(void) fprintf(el->el_errfile, "%s: tty_getty: %s\n", __func__, |
| 518 |
strerror(errno)); |
| 519 |
#endif /* DEBUG_TTY */ |
| 520 |
return -1; |
| 521 |
} |
| 522 |
el->el_tty.t_ts = el->el_tty.t_ex = el->el_tty.t_ed = el->el_tty.t_or; |
| 523 |
|
| 524 |
el->el_tty.t_speed = tty__getspeed(&el->el_tty.t_ex); |
| 525 |
el->el_tty.t_tabs = tty__gettabs(&el->el_tty.t_ex); |
| 526 |
el->el_tty.t_eight = tty__geteightbit(&el->el_tty.t_ex); |
| 527 |
|
| 528 |
tty_setup_flags(el, &el->el_tty.t_ex, EX_IO); |
| 529 |
|
| 530 |
/* |
| 531 |
* Reset the tty chars to reasonable defaults |
| 532 |
* If they are disabled, then enable them. |
| 533 |
*/ |
| 534 |
if (rst) { |
| 535 |
if (tty__cooked_mode(&el->el_tty.t_ts)) { |
| 536 |
tty__getchar(&el->el_tty.t_ts, el->el_tty.t_c[TS_IO]); |
| 537 |
/* |
| 538 |
* Don't affect CMIN and CTIME for the editor mode |
| 539 |
*/ |
| 540 |
for (rst = 0; rst < C_NCC - 2; rst++) |
| 541 |
if (el->el_tty.t_c[TS_IO][rst] != |
| 542 |
el->el_tty.t_vdisable |
| 543 |
&& el->el_tty.t_c[ED_IO][rst] != |
| 544 |
el->el_tty.t_vdisable) |
| 545 |
el->el_tty.t_c[ED_IO][rst] = |
| 546 |
el->el_tty.t_c[TS_IO][rst]; |
| 547 |
for (rst = 0; rst < C_NCC; rst++) |
| 548 |
if (el->el_tty.t_c[TS_IO][rst] != |
| 549 |
el->el_tty.t_vdisable) |
| 550 |
el->el_tty.t_c[EX_IO][rst] = |
| 551 |
el->el_tty.t_c[TS_IO][rst]; |
| 552 |
} |
| 553 |
tty__setchar(&el->el_tty.t_ex, el->el_tty.t_c[EX_IO]); |
| 554 |
if (tty_setty(el, TCSADRAIN, &el->el_tty.t_ex) == -1) { |
| 555 |
#ifdef DEBUG_TTY |
| 556 |
(void) fprintf(el->el_errfile, "%s: tty_setty: %s\n", |
| 557 |
__func__, strerror(errno)); |
| 558 |
#endif /* DEBUG_TTY */ |
| 559 |
return -1; |
| 560 |
} |
| 561 |
} |
| 562 |
|
| 563 |
tty_setup_flags(el, &el->el_tty.t_ed, ED_IO); |
| 564 |
|
| 565 |
tty__setchar(&el->el_tty.t_ed, el->el_tty.t_c[ED_IO]); |
| 566 |
tty_bind_char(el, 1); |
| 567 |
el->el_tty.t_initialized = 1; |
| 568 |
return 0; |
| 569 |
} |
| 570 |
|
| 571 |
libedit_private int |
| 572 |
tty_init(EditLine *el) |
| 573 |
{ |
| 574 |
|
| 575 |
el->el_tty.t_mode = EX_IO; |
| 576 |
el->el_tty.t_vdisable = _POSIX_VDISABLE; |
| 577 |
el->el_tty.t_initialized = 0; |
| 578 |
(void) memcpy(el->el_tty.t_t, ttyperm, sizeof(ttyperm_t)); |
| 579 |
(void) memcpy(el->el_tty.t_c, ttychar, sizeof(ttychar_t)); |
| 580 |
return tty_setup(el); |
| 581 |
} |
| 582 |
|
| 583 |
|
| 584 |
/* tty_end(): |
| 585 |
* Restore the tty to its original settings |
| 586 |
*/ |
| 587 |
libedit_private void |
| 588 |
/*ARGSUSED*/ |
| 589 |
tty_end(EditLine *el) |
| 590 |
{ |
| 591 |
if (el->el_flags & EDIT_DISABLED) |
| 592 |
return; |
| 593 |
|
| 594 |
if (!el->el_tty.t_initialized) |
| 595 |
return; |
| 596 |
|
| 597 |
if (tty_setty(el, TCSAFLUSH, &el->el_tty.t_or) == -1) { |
| 598 |
#ifdef DEBUG_TTY |
| 599 |
(void) fprintf(el->el_errfile, |
| 600 |
"%s: tty_setty: %s\n", __func__, strerror(errno)); |
| 601 |
#endif /* DEBUG_TTY */ |
| 602 |
} |
| 603 |
} |
| 604 |
|
| 605 |
|
| 606 |
/* tty__getspeed(): |
| 607 |
* Get the tty speed |
| 608 |
*/ |
| 609 |
static speed_t |
| 610 |
tty__getspeed(struct termios *td) |
| 611 |
{ |
| 612 |
speed_t spd; |
| 613 |
|
| 614 |
if ((spd = cfgetispeed(td)) == 0) |
| 615 |
spd = cfgetospeed(td); |
| 616 |
return spd; |
| 617 |
} |
| 618 |
|
| 619 |
/* tty__getspeed(): |
| 620 |
* Return the index of the asked char in the c_cc array |
| 621 |
*/ |
| 622 |
static int |
| 623 |
tty__getcharindex(int i) |
| 624 |
{ |
| 625 |
switch (i) { |
| 626 |
#ifdef VINTR |
| 627 |
case C_INTR: |
| 628 |
return VINTR; |
| 629 |
#endif /* VINTR */ |
| 630 |
#ifdef VQUIT |
| 631 |
case C_QUIT: |
| 632 |
return VQUIT; |
| 633 |
#endif /* VQUIT */ |
| 634 |
#ifdef VERASE |
| 635 |
case C_ERASE: |
| 636 |
return VERASE; |
| 637 |
#endif /* VERASE */ |
| 638 |
#ifdef VKILL |
| 639 |
case C_KILL: |
| 640 |
return VKILL; |
| 641 |
#endif /* VKILL */ |
| 642 |
#ifdef VEOF |
| 643 |
case C_EOF: |
| 644 |
return VEOF; |
| 645 |
#endif /* VEOF */ |
| 646 |
#ifdef VEOL |
| 647 |
case C_EOL: |
| 648 |
return VEOL; |
| 649 |
#endif /* VEOL */ |
| 650 |
#ifdef VEOL2 |
| 651 |
case C_EOL2: |
| 652 |
return VEOL2; |
| 653 |
#endif /* VEOL2 */ |
| 654 |
#ifdef VSWTCH |
| 655 |
case C_SWTCH: |
| 656 |
return VSWTCH; |
| 657 |
#endif /* VSWTCH */ |
| 658 |
#ifdef VDSWTCH |
| 659 |
case C_DSWTCH: |
| 660 |
return VDSWTCH; |
| 661 |
#endif /* VDSWTCH */ |
| 662 |
#ifdef VERASE2 |
| 663 |
case C_ERASE2: |
| 664 |
return VERASE2; |
| 665 |
#endif /* VERASE2 */ |
| 666 |
#ifdef VSTART |
| 667 |
case C_START: |
| 668 |
return VSTART; |
| 669 |
#endif /* VSTART */ |
| 670 |
#ifdef VSTOP |
| 671 |
case C_STOP: |
| 672 |
return VSTOP; |
| 673 |
#endif /* VSTOP */ |
| 674 |
#ifdef VWERASE |
| 675 |
case C_WERASE: |
| 676 |
return VWERASE; |
| 677 |
#endif /* VWERASE */ |
| 678 |
#ifdef VSUSP |
| 679 |
case C_SUSP: |
| 680 |
return VSUSP; |
| 681 |
#endif /* VSUSP */ |
| 682 |
#ifdef VDSUSP |
| 683 |
case C_DSUSP: |
| 684 |
return VDSUSP; |
| 685 |
#endif /* VDSUSP */ |
| 686 |
#ifdef VREPRINT |
| 687 |
case C_REPRINT: |
| 688 |
return VREPRINT; |
| 689 |
#endif /* VREPRINT */ |
| 690 |
#ifdef VDISCARD |
| 691 |
case C_DISCARD: |
| 692 |
return VDISCARD; |
| 693 |
#endif /* VDISCARD */ |
| 694 |
#ifdef VLNEXT |
| 695 |
case C_LNEXT: |
| 696 |
return VLNEXT; |
| 697 |
#endif /* VLNEXT */ |
| 698 |
#ifdef VSTATUS |
| 699 |
case C_STATUS: |
| 700 |
return VSTATUS; |
| 701 |
#endif /* VSTATUS */ |
| 702 |
#ifdef VPAGE |
| 703 |
case C_PAGE: |
| 704 |
return VPAGE; |
| 705 |
#endif /* VPAGE */ |
| 706 |
#ifdef VPGOFF |
| 707 |
case C_PGOFF: |
| 708 |
return VPGOFF; |
| 709 |
#endif /* VPGOFF */ |
| 710 |
#ifdef VKILL2 |
| 711 |
case C_KILL2: |
| 712 |
return VKILL2; |
| 713 |
#endif /* KILL2 */ |
| 714 |
#ifdef VMIN |
| 715 |
case C_MIN: |
| 716 |
return VMIN; |
| 717 |
#endif /* VMIN */ |
| 718 |
#ifdef VTIME |
| 719 |
case C_TIME: |
| 720 |
return VTIME; |
| 721 |
#endif /* VTIME */ |
| 722 |
default: |
| 723 |
return -1; |
| 724 |
} |
| 725 |
} |
| 726 |
|
| 727 |
/* tty__getchar(): |
| 728 |
* Get the tty characters |
| 729 |
*/ |
| 730 |
static void |
| 731 |
tty__getchar(struct termios *td, unsigned char *s) |
| 732 |
{ |
| 733 |
|
| 734 |
#ifdef VINTR |
| 735 |
s[C_INTR] = td->c_cc[VINTR]; |
| 736 |
#endif /* VINTR */ |
| 737 |
#ifdef VQUIT |
| 738 |
s[C_QUIT] = td->c_cc[VQUIT]; |
| 739 |
#endif /* VQUIT */ |
| 740 |
#ifdef VERASE |
| 741 |
s[C_ERASE] = td->c_cc[VERASE]; |
| 742 |
#endif /* VERASE */ |
| 743 |
#ifdef VKILL |
| 744 |
s[C_KILL] = td->c_cc[VKILL]; |
| 745 |
#endif /* VKILL */ |
| 746 |
#ifdef VEOF |
| 747 |
s[C_EOF] = td->c_cc[VEOF]; |
| 748 |
#endif /* VEOF */ |
| 749 |
#ifdef VEOL |
| 750 |
s[C_EOL] = td->c_cc[VEOL]; |
| 751 |
#endif /* VEOL */ |
| 752 |
#ifdef VEOL2 |
| 753 |
s[C_EOL2] = td->c_cc[VEOL2]; |
| 754 |
#endif /* VEOL2 */ |
| 755 |
#ifdef VSWTCH |
| 756 |
s[C_SWTCH] = td->c_cc[VSWTCH]; |
| 757 |
#endif /* VSWTCH */ |
| 758 |
#ifdef VDSWTCH |
| 759 |
s[C_DSWTCH] = td->c_cc[VDSWTCH]; |
| 760 |
#endif /* VDSWTCH */ |
| 761 |
#ifdef VERASE2 |
| 762 |
s[C_ERASE2] = td->c_cc[VERASE2]; |
| 763 |
#endif /* VERASE2 */ |
| 764 |
#ifdef VSTART |
| 765 |
s[C_START] = td->c_cc[VSTART]; |
| 766 |
#endif /* VSTART */ |
| 767 |
#ifdef VSTOP |
| 768 |
s[C_STOP] = td->c_cc[VSTOP]; |
| 769 |
#endif /* VSTOP */ |
| 770 |
#ifdef VWERASE |
| 771 |
s[C_WERASE] = td->c_cc[VWERASE]; |
| 772 |
#endif /* VWERASE */ |
| 773 |
#ifdef VSUSP |
| 774 |
s[C_SUSP] = td->c_cc[VSUSP]; |
| 775 |
#endif /* VSUSP */ |
| 776 |
#ifdef VDSUSP |
| 777 |
s[C_DSUSP] = td->c_cc[VDSUSP]; |
| 778 |
#endif /* VDSUSP */ |
| 779 |
#ifdef VREPRINT |
| 780 |
s[C_REPRINT] = td->c_cc[VREPRINT]; |
| 781 |
#endif /* VREPRINT */ |
| 782 |
#ifdef VDISCARD |
| 783 |
s[C_DISCARD] = td->c_cc[VDISCARD]; |
| 784 |
#endif /* VDISCARD */ |
| 785 |
#ifdef VLNEXT |
| 786 |
s[C_LNEXT] = td->c_cc[VLNEXT]; |
| 787 |
#endif /* VLNEXT */ |
| 788 |
#ifdef VSTATUS |
| 789 |
s[C_STATUS] = td->c_cc[VSTATUS]; |
| 790 |
#endif /* VSTATUS */ |
| 791 |
#ifdef VPAGE |
| 792 |
s[C_PAGE] = td->c_cc[VPAGE]; |
| 793 |
#endif /* VPAGE */ |
| 794 |
#ifdef VPGOFF |
| 795 |
s[C_PGOFF] = td->c_cc[VPGOFF]; |
| 796 |
#endif /* VPGOFF */ |
| 797 |
#ifdef VKILL2 |
| 798 |
s[C_KILL2] = td->c_cc[VKILL2]; |
| 799 |
#endif /* KILL2 */ |
| 800 |
#ifdef VMIN |
| 801 |
s[C_MIN] = td->c_cc[VMIN]; |
| 802 |
#endif /* VMIN */ |
| 803 |
#ifdef VTIME |
| 804 |
s[C_TIME] = td->c_cc[VTIME]; |
| 805 |
#endif /* VTIME */ |
| 806 |
} /* tty__getchar */ |
| 807 |
|
| 808 |
|
| 809 |
/* tty__setchar(): |
| 810 |
* Set the tty characters |
| 811 |
*/ |
| 812 |
static void |
| 813 |
tty__setchar(struct termios *td, unsigned char *s) |
| 814 |
{ |
| 815 |
|
| 816 |
#ifdef VINTR |
| 817 |
td->c_cc[VINTR] = s[C_INTR]; |
| 818 |
#endif /* VINTR */ |
| 819 |
#ifdef VQUIT |
| 820 |
td->c_cc[VQUIT] = s[C_QUIT]; |
| 821 |
#endif /* VQUIT */ |
| 822 |
#ifdef VERASE |
| 823 |
td->c_cc[VERASE] = s[C_ERASE]; |
| 824 |
#endif /* VERASE */ |
| 825 |
#ifdef VKILL |
| 826 |
td->c_cc[VKILL] = s[C_KILL]; |
| 827 |
#endif /* VKILL */ |
| 828 |
#ifdef VEOF |
| 829 |
td->c_cc[VEOF] = s[C_EOF]; |
| 830 |
#endif /* VEOF */ |
| 831 |
#ifdef VEOL |
| 832 |
td->c_cc[VEOL] = s[C_EOL]; |
| 833 |
#endif /* VEOL */ |
| 834 |
#ifdef VEOL2 |
| 835 |
td->c_cc[VEOL2] = s[C_EOL2]; |
| 836 |
#endif /* VEOL2 */ |
| 837 |
#ifdef VSWTCH |
| 838 |
td->c_cc[VSWTCH] = s[C_SWTCH]; |
| 839 |
#endif /* VSWTCH */ |
| 840 |
#ifdef VDSWTCH |
| 841 |
td->c_cc[VDSWTCH] = s[C_DSWTCH]; |
| 842 |
#endif /* VDSWTCH */ |
| 843 |
#ifdef VERASE2 |
| 844 |
td->c_cc[VERASE2] = s[C_ERASE2]; |
| 845 |
#endif /* VERASE2 */ |
| 846 |
#ifdef VSTART |
| 847 |
td->c_cc[VSTART] = s[C_START]; |
| 848 |
#endif /* VSTART */ |
| 849 |
#ifdef VSTOP |
| 850 |
td->c_cc[VSTOP] = s[C_STOP]; |
| 851 |
#endif /* VSTOP */ |
| 852 |
#ifdef VWERASE |
| 853 |
td->c_cc[VWERASE] = s[C_WERASE]; |
| 854 |
#endif /* VWERASE */ |
| 855 |
#ifdef VSUSP |
| 856 |
td->c_cc[VSUSP] = s[C_SUSP]; |
| 857 |
#endif /* VSUSP */ |
| 858 |
#ifdef VDSUSP |
| 859 |
td->c_cc[VDSUSP] = s[C_DSUSP]; |
| 860 |
#endif /* VDSUSP */ |
| 861 |
#ifdef VREPRINT |
| 862 |
td->c_cc[VREPRINT] = s[C_REPRINT]; |
| 863 |
#endif /* VREPRINT */ |
| 864 |
#ifdef VDISCARD |
| 865 |
td->c_cc[VDISCARD] = s[C_DISCARD]; |
| 866 |
#endif /* VDISCARD */ |
| 867 |
#ifdef VLNEXT |
| 868 |
td->c_cc[VLNEXT] = s[C_LNEXT]; |
| 869 |
#endif /* VLNEXT */ |
| 870 |
#ifdef VSTATUS |
| 871 |
td->c_cc[VSTATUS] = s[C_STATUS]; |
| 872 |
#endif /* VSTATUS */ |
| 873 |
#ifdef VPAGE |
| 874 |
td->c_cc[VPAGE] = s[C_PAGE]; |
| 875 |
#endif /* VPAGE */ |
| 876 |
#ifdef VPGOFF |
| 877 |
td->c_cc[VPGOFF] = s[C_PGOFF]; |
| 878 |
#endif /* VPGOFF */ |
| 879 |
#ifdef VKILL2 |
| 880 |
td->c_cc[VKILL2] = s[C_KILL2]; |
| 881 |
#endif /* VKILL2 */ |
| 882 |
#ifdef VMIN |
| 883 |
td->c_cc[VMIN] = s[C_MIN]; |
| 884 |
#endif /* VMIN */ |
| 885 |
#ifdef VTIME |
| 886 |
td->c_cc[VTIME] = s[C_TIME]; |
| 887 |
#endif /* VTIME */ |
| 888 |
} /* tty__setchar */ |
| 889 |
|
| 890 |
|
| 891 |
/* tty_bind_char(): |
| 892 |
* Rebind the editline functions |
| 893 |
*/ |
| 894 |
libedit_private void |
| 895 |
tty_bind_char(EditLine *el, int force) |
| 896 |
{ |
| 897 |
|
| 898 |
unsigned char *t_n = el->el_tty.t_c[ED_IO]; |
| 899 |
unsigned char *t_o = el->el_tty.t_ed.c_cc; |
| 900 |
wchar_t new[2], old[2]; |
| 901 |
const ttymap_t *tp; |
| 902 |
el_action_t *map, *alt; |
| 903 |
const el_action_t *dmap, *dalt; |
| 904 |
new[1] = old[1] = '\0'; |
| 905 |
|
| 906 |
map = el->el_map.key; |
| 907 |
alt = el->el_map.alt; |
| 908 |
if (el->el_map.type == MAP_VI) { |
| 909 |
dmap = el->el_map.vii; |
| 910 |
dalt = el->el_map.vic; |
| 911 |
} else { |
| 912 |
dmap = el->el_map.emacs; |
| 913 |
dalt = NULL; |
| 914 |
} |
| 915 |
|
| 916 |
for (tp = tty_map; tp->nch != (wint_t)-1; tp++) { |
| 917 |
new[0] = (wchar_t)t_n[tp->nch]; |
| 918 |
old[0] = (wchar_t)t_o[tp->och]; |
| 919 |
if (new[0] == old[0] && !force) |
| 920 |
continue; |
| 921 |
/* Put the old default binding back, and set the new binding */ |
| 922 |
keymacro_clear(el, map, old); |
| 923 |
map[(unsigned char)old[0]] = dmap[(unsigned char)old[0]]; |
| 924 |
keymacro_clear(el, map, new); |
| 925 |
/* MAP_VI == 1, MAP_EMACS == 0... */ |
| 926 |
map[(unsigned char)new[0]] = tp->bind[el->el_map.type]; |
| 927 |
if (dalt) { |
| 928 |
keymacro_clear(el, alt, old); |
| 929 |
alt[(unsigned char)old[0]] = |
| 930 |
dalt[(unsigned char)old[0]]; |
| 931 |
keymacro_clear(el, alt, new); |
| 932 |
alt[(unsigned char)new[0]] = |
| 933 |
tp->bind[el->el_map.type + 1]; |
| 934 |
} |
| 935 |
} |
| 936 |
} |
| 937 |
|
| 938 |
|
| 939 |
static tcflag_t * |
| 940 |
tty__get_flag(struct termios *t, int kind) { |
| 941 |
switch (kind) { |
| 942 |
case MD_INP: |
| 943 |
return &t->c_iflag; |
| 944 |
case MD_OUT: |
| 945 |
return &t->c_oflag; |
| 946 |
case MD_CTL: |
| 947 |
return &t->c_cflag; |
| 948 |
case MD_LIN: |
| 949 |
return &t->c_lflag; |
| 950 |
default: |
| 951 |
abort(); |
| 952 |
/*NOTREACHED*/ |
| 953 |
} |
| 954 |
} |
| 955 |
|
| 956 |
|
| 957 |
static tcflag_t |
| 958 |
tty_update_flag(EditLine *el, tcflag_t f, int mode, int kind) |
| 959 |
{ |
| 960 |
f &= ~el->el_tty.t_t[mode][kind].t_clrmask; |
| 961 |
f |= el->el_tty.t_t[mode][kind].t_setmask; |
| 962 |
return f; |
| 963 |
} |
| 964 |
|
| 965 |
|
| 966 |
static void |
| 967 |
tty_update_flags(EditLine *el, int kind) |
| 968 |
{ |
| 969 |
tcflag_t *tt, *ed, *ex; |
| 970 |
tt = tty__get_flag(&el->el_tty.t_ts, kind); |
| 971 |
ed = tty__get_flag(&el->el_tty.t_ed, kind); |
| 972 |
ex = tty__get_flag(&el->el_tty.t_ex, kind); |
| 973 |
|
| 974 |
if (*tt != *ex && (kind != MD_CTL || *tt != *ed)) { |
| 975 |
*ed = tty_update_flag(el, *tt, ED_IO, kind); |
| 976 |
*ex = tty_update_flag(el, *tt, EX_IO, kind); |
| 977 |
} |
| 978 |
} |
| 979 |
|
| 980 |
|
| 981 |
static void |
| 982 |
tty_update_char(EditLine *el, int mode, int c) { |
| 983 |
if (!((el->el_tty.t_t[mode][MD_CHAR].t_setmask & C_SH(c))) |
| 984 |
&& (el->el_tty.t_c[TS_IO][c] != el->el_tty.t_c[EX_IO][c])) |
| 985 |
el->el_tty.t_c[mode][c] = el->el_tty.t_c[TS_IO][c]; |
| 986 |
if (el->el_tty.t_t[mode][MD_CHAR].t_clrmask & C_SH(c)) |
| 987 |
el->el_tty.t_c[mode][c] = el->el_tty.t_vdisable; |
| 988 |
} |
| 989 |
|
| 990 |
|
| 991 |
/* tty_rawmode(): |
| 992 |
* Set terminal into 1 character at a time mode. |
| 993 |
*/ |
| 994 |
libedit_private int |
| 995 |
tty_rawmode(EditLine *el) |
| 996 |
{ |
| 997 |
|
| 998 |
if (el->el_tty.t_mode == ED_IO || el->el_tty.t_mode == QU_IO) |
| 999 |
return 0; |
| 1000 |
|
| 1001 |
if (el->el_flags & EDIT_DISABLED) |
| 1002 |
return 0; |
| 1003 |
|
| 1004 |
if (tty_getty(el, &el->el_tty.t_ts) == -1) { |
| 1005 |
#ifdef DEBUG_TTY |
| 1006 |
(void) fprintf(el->el_errfile, "%s: tty_getty: %s\n", __func__, |
| 1007 |
strerror(errno)); |
| 1008 |
#endif /* DEBUG_TTY */ |
| 1009 |
return -1; |
| 1010 |
} |
| 1011 |
/* |
| 1012 |
* We always keep up with the eight bit setting and the speed of the |
| 1013 |
* tty. But we only believe changes that are made to cooked mode! |
| 1014 |
*/ |
| 1015 |
el->el_tty.t_eight = tty__geteightbit(&el->el_tty.t_ts); |
| 1016 |
el->el_tty.t_speed = tty__getspeed(&el->el_tty.t_ts); |
| 1017 |
|
| 1018 |
if (tty__getspeed(&el->el_tty.t_ex) != el->el_tty.t_speed || |
| 1019 |
tty__getspeed(&el->el_tty.t_ed) != el->el_tty.t_speed) { |
| 1020 |
(void) cfsetispeed(&el->el_tty.t_ex, el->el_tty.t_speed); |
| 1021 |
(void) cfsetospeed(&el->el_tty.t_ex, el->el_tty.t_speed); |
| 1022 |
(void) cfsetispeed(&el->el_tty.t_ed, el->el_tty.t_speed); |
| 1023 |
(void) cfsetospeed(&el->el_tty.t_ed, el->el_tty.t_speed); |
| 1024 |
} |
| 1025 |
if (tty__cooked_mode(&el->el_tty.t_ts)) { |
| 1026 |
int i; |
| 1027 |
|
| 1028 |
for (i = MD_INP; i <= MD_LIN; i++) |
| 1029 |
tty_update_flags(el, i); |
| 1030 |
|
| 1031 |
if (tty__gettabs(&el->el_tty.t_ex) == 0) |
| 1032 |
el->el_tty.t_tabs = 0; |
| 1033 |
else |
| 1034 |
el->el_tty.t_tabs = EL_CAN_TAB ? 1 : 0; |
| 1035 |
|
| 1036 |
tty__getchar(&el->el_tty.t_ts, el->el_tty.t_c[TS_IO]); |
| 1037 |
/* |
| 1038 |
* Check if the user made any changes. |
| 1039 |
* If he did, then propagate the changes to the |
| 1040 |
* edit and execute data structures. |
| 1041 |
*/ |
| 1042 |
for (i = 0; i < C_NCC; i++) |
| 1043 |
if (el->el_tty.t_c[TS_IO][i] != |
| 1044 |
el->el_tty.t_c[EX_IO][i]) |
| 1045 |
break; |
| 1046 |
|
| 1047 |
if (i != C_NCC) { |
| 1048 |
/* |
| 1049 |
* Propagate changes only to the unlibedit_private |
| 1050 |
* chars that have been modified just now. |
| 1051 |
*/ |
| 1052 |
for (i = 0; i < C_NCC; i++) |
| 1053 |
tty_update_char(el, ED_IO, i); |
| 1054 |
|
| 1055 |
tty_bind_char(el, 0); |
| 1056 |
tty__setchar(&el->el_tty.t_ed, el->el_tty.t_c[ED_IO]); |
| 1057 |
|
| 1058 |
for (i = 0; i < C_NCC; i++) |
| 1059 |
tty_update_char(el, EX_IO, i); |
| 1060 |
|
| 1061 |
tty__setchar(&el->el_tty.t_ex, el->el_tty.t_c[EX_IO]); |
| 1062 |
} |
| 1063 |
} |
| 1064 |
if (tty_setty(el, TCSADRAIN, &el->el_tty.t_ed) == -1) { |
| 1065 |
#ifdef DEBUG_TTY |
| 1066 |
(void) fprintf(el->el_errfile, "%s: tty_setty: %s\n", __func__, |
| 1067 |
strerror(errno)); |
| 1068 |
#endif /* DEBUG_TTY */ |
| 1069 |
return -1; |
| 1070 |
} |
| 1071 |
el->el_tty.t_mode = ED_IO; |
| 1072 |
return 0; |
| 1073 |
} |
| 1074 |
|
| 1075 |
|
| 1076 |
/* tty_cookedmode(): |
| 1077 |
* Set the tty back to normal mode |
| 1078 |
*/ |
| 1079 |
libedit_private int |
| 1080 |
tty_cookedmode(EditLine *el) |
| 1081 |
{ /* set tty in normal setup */ |
| 1082 |
|
| 1083 |
if (el->el_tty.t_mode == EX_IO) |
| 1084 |
return 0; |
| 1085 |
|
| 1086 |
if (el->el_flags & EDIT_DISABLED) |
| 1087 |
return 0; |
| 1088 |
|
| 1089 |
if (tty_setty(el, TCSADRAIN, &el->el_tty.t_ex) == -1) { |
| 1090 |
#ifdef DEBUG_TTY |
| 1091 |
(void) fprintf(el->el_errfile, "%s: tty_setty: %s\n", __func__, |
| 1092 |
strerror(errno)); |
| 1093 |
#endif /* DEBUG_TTY */ |
| 1094 |
return -1; |
| 1095 |
} |
| 1096 |
el->el_tty.t_mode = EX_IO; |
| 1097 |
return 0; |
| 1098 |
} |
| 1099 |
|
| 1100 |
|
| 1101 |
/* tty_quotemode(): |
| 1102 |
* Turn on quote mode |
| 1103 |
*/ |
| 1104 |
libedit_private int |
| 1105 |
tty_quotemode(EditLine *el) |
| 1106 |
{ |
| 1107 |
if (el->el_tty.t_mode == QU_IO) |
| 1108 |
return 0; |
| 1109 |
|
| 1110 |
el->el_tty.t_qu = el->el_tty.t_ed; |
| 1111 |
|
| 1112 |
tty_setup_flags(el, &el->el_tty.t_qu, QU_IO); |
| 1113 |
|
| 1114 |
if (tty_setty(el, TCSADRAIN, &el->el_tty.t_qu) == -1) { |
| 1115 |
#ifdef DEBUG_TTY |
| 1116 |
(void) fprintf(el->el_errfile, "%s: tty_setty: %s\n", __func__, |
| 1117 |
strerror(errno)); |
| 1118 |
#endif /* DEBUG_TTY */ |
| 1119 |
return -1; |
| 1120 |
} |
| 1121 |
el->el_tty.t_mode = QU_IO; |
| 1122 |
return 0; |
| 1123 |
} |
| 1124 |
|
| 1125 |
|
| 1126 |
/* tty_noquotemode(): |
| 1127 |
* Turn off quote mode |
| 1128 |
*/ |
| 1129 |
libedit_private int |
| 1130 |
tty_noquotemode(EditLine *el) |
| 1131 |
{ |
| 1132 |
|
| 1133 |
if (el->el_tty.t_mode != QU_IO) |
| 1134 |
return 0; |
| 1135 |
if (tty_setty(el, TCSADRAIN, &el->el_tty.t_ed) == -1) { |
| 1136 |
#ifdef DEBUG_TTY |
| 1137 |
(void) fprintf(el->el_errfile, "%s: tty_setty: %s\n", __func__, |
| 1138 |
strerror(errno)); |
| 1139 |
#endif /* DEBUG_TTY */ |
| 1140 |
return -1; |
| 1141 |
} |
| 1142 |
el->el_tty.t_mode = ED_IO; |
| 1143 |
return 0; |
| 1144 |
} |
| 1145 |
|
| 1146 |
|
| 1147 |
/* tty_stty(): |
| 1148 |
* Stty builtin |
| 1149 |
*/ |
| 1150 |
libedit_private int |
| 1151 |
/*ARGSUSED*/ |
| 1152 |
tty_stty(EditLine *el, int argc __attribute__((__unused__)), |
| 1153 |
const wchar_t **argv) |
| 1154 |
{ |
| 1155 |
const ttymodes_t *m; |
| 1156 |
char x; |
| 1157 |
int aflag = 0; |
| 1158 |
const wchar_t *s, *d; |
| 1159 |
char name[EL_BUFSIZ]; |
| 1160 |
struct termios *tios = &el->el_tty.t_ex; |
| 1161 |
int z = EX_IO; |
| 1162 |
|
| 1163 |
if (argv == NULL) |
| 1164 |
return -1; |
| 1165 |
strncpy(name, ct_encode_string(*argv++, &el->el_scratch), sizeof(name)); |
| 1166 |
name[sizeof(name) - 1] = '\0'; |
| 1167 |
|
| 1168 |
while (argv && *argv && argv[0][0] == '-' && argv[0][2] == '\0') |
| 1169 |
switch (argv[0][1]) { |
| 1170 |
case 'a': |
| 1171 |
aflag++; |
| 1172 |
argv++; |
| 1173 |
break; |
| 1174 |
case 'd': |
| 1175 |
argv++; |
| 1176 |
tios = &el->el_tty.t_ed; |
| 1177 |
z = ED_IO; |
| 1178 |
break; |
| 1179 |
case 'x': |
| 1180 |
argv++; |
| 1181 |
tios = &el->el_tty.t_ex; |
| 1182 |
z = EX_IO; |
| 1183 |
break; |
| 1184 |
case 'q': |
| 1185 |
argv++; |
| 1186 |
tios = &el->el_tty.t_ts; |
| 1187 |
z = QU_IO; |
| 1188 |
break; |
| 1189 |
default: |
| 1190 |
(void) fprintf(el->el_errfile, |
| 1191 |
"%s: Unknown switch `%lc'.\n", |
| 1192 |
name, (wint_t)argv[0][1]); |
| 1193 |
return -1; |
| 1194 |
} |
| 1195 |
|
| 1196 |
if (!argv || !*argv) { |
| 1197 |
int i = -1; |
| 1198 |
size_t len = 0, st = 0, cu; |
| 1199 |
for (m = ttymodes; m->m_name; m++) { |
| 1200 |
if (m->m_type != i) { |
| 1201 |
(void) fprintf(el->el_outfile, "%s%s", |
| 1202 |
i != -1 ? "\n" : "", |
| 1203 |
el->el_tty.t_t[z][m->m_type].t_name); |
| 1204 |
i = m->m_type; |
| 1205 |
st = len = |
| 1206 |
strlen(el->el_tty.t_t[z][m->m_type].t_name); |
| 1207 |
} |
| 1208 |
if (i != -1) { |
| 1209 |
x = (el->el_tty.t_t[z][i].t_setmask & m->m_value) |
| 1210 |
? '+' : '\0'; |
| 1211 |
|
| 1212 |
if (el->el_tty.t_t[z][i].t_clrmask & m->m_value) |
| 1213 |
x = '-'; |
| 1214 |
} else { |
| 1215 |
x = '\0'; |
| 1216 |
} |
| 1217 |
|
| 1218 |
if (x != '\0' || aflag) { |
| 1219 |
|
| 1220 |
cu = strlen(m->m_name) + (x != '\0') + 1; |
| 1221 |
|
| 1222 |
if (len + cu >= |
| 1223 |
(size_t)el->el_terminal.t_size.h) { |
| 1224 |
(void) fprintf(el->el_outfile, "\n%*s", |
| 1225 |
(int)st, ""); |
| 1226 |
len = st + cu; |
| 1227 |
} else |
| 1228 |
len += cu; |
| 1229 |
|
| 1230 |
if (x != '\0') |
| 1231 |
(void) fprintf(el->el_outfile, "%c%s ", |
| 1232 |
x, m->m_name); |
| 1233 |
else |
| 1234 |
(void) fprintf(el->el_outfile, "%s ", |
| 1235 |
m->m_name); |
| 1236 |
} |
| 1237 |
} |
| 1238 |
(void) fprintf(el->el_outfile, "\n"); |
| 1239 |
return 0; |
| 1240 |
} |
| 1241 |
while (argv && (s = *argv++)) { |
| 1242 |
const wchar_t *p; |
| 1243 |
switch (*s) { |
| 1244 |
case '+': |
| 1245 |
case '-': |
| 1246 |
x = (char)*s++; |
| 1247 |
break; |
| 1248 |
default: |
| 1249 |
x = '\0'; |
| 1250 |
break; |
| 1251 |
} |
| 1252 |
d = s; |
| 1253 |
p = wcschr(s, L'='); |
| 1254 |
for (m = ttymodes; m->m_name; m++) |
| 1255 |
if ((p ? strncmp(m->m_name, ct_encode_string(d, |
| 1256 |
&el->el_scratch), (size_t)(p - d)) : |
| 1257 |
strcmp(m->m_name, ct_encode_string(d, |
| 1258 |
&el->el_scratch))) == 0 && |
| 1259 |
(p == NULL || m->m_type == MD_CHAR)) |
| 1260 |
break; |
| 1261 |
|
| 1262 |
if (!m->m_name) { |
| 1263 |
(void) fprintf(el->el_errfile, |
| 1264 |
"%s: Invalid argument `%ls'.\n", name, d); |
| 1265 |
return -1; |
| 1266 |
} |
| 1267 |
if (p) { |
| 1268 |
int c = ffs((int)m->m_value); |
| 1269 |
int v = *++p ? parse__escape(&p) : |
| 1270 |
el->el_tty.t_vdisable; |
| 1271 |
assert(c != 0); |
| 1272 |
c--; |
| 1273 |
c = tty__getcharindex(c); |
| 1274 |
assert(c != -1); |
| 1275 |
tios->c_cc[c] = (cc_t)v; |
| 1276 |
continue; |
| 1277 |
} |
| 1278 |
switch (x) { |
| 1279 |
case '+': |
| 1280 |
el->el_tty.t_t[z][m->m_type].t_setmask |= m->m_value; |
| 1281 |
el->el_tty.t_t[z][m->m_type].t_clrmask &= ~m->m_value; |
| 1282 |
break; |
| 1283 |
case '-': |
| 1284 |
el->el_tty.t_t[z][m->m_type].t_setmask &= ~m->m_value; |
| 1285 |
el->el_tty.t_t[z][m->m_type].t_clrmask |= m->m_value; |
| 1286 |
break; |
| 1287 |
default: |
| 1288 |
el->el_tty.t_t[z][m->m_type].t_setmask &= ~m->m_value; |
| 1289 |
el->el_tty.t_t[z][m->m_type].t_clrmask &= ~m->m_value; |
| 1290 |
break; |
| 1291 |
} |
| 1292 |
} |
| 1293 |
|
| 1294 |
tty_setup_flags(el, tios, z); |
| 1295 |
if (el->el_tty.t_mode == z) { |
| 1296 |
if (tty_setty(el, TCSADRAIN, tios) == -1) { |
| 1297 |
#ifdef DEBUG_TTY |
| 1298 |
(void) fprintf(el->el_errfile, "%s: tty_setty: %s\n", |
| 1299 |
__func__, strerror(errno)); |
| 1300 |
#endif /* DEBUG_TTY */ |
| 1301 |
return -1; |
| 1302 |
} |
| 1303 |
} |
| 1304 |
|
| 1305 |
return 0; |
| 1306 |
} |
| 1307 |
|
| 1308 |
|
| 1309 |
#ifdef notyet |
| 1310 |
/* tty_printchar(): |
| 1311 |
* DEbugging routine to print the tty characters |
| 1312 |
*/ |
| 1313 |
static void |
| 1314 |
tty_printchar(EditLine *el, unsigned char *s) |
| 1315 |
{ |
| 1316 |
ttyperm_t *m; |
| 1317 |
int i; |
| 1318 |
|
| 1319 |
for (i = 0; i < C_NCC; i++) { |
| 1320 |
for (m = el->el_tty.t_t; m->m_name; m++) |
| 1321 |
if (m->m_type == MD_CHAR && C_SH(i) == m->m_value) |
| 1322 |
break; |
| 1323 |
if (m->m_name) |
| 1324 |
(void) fprintf(el->el_errfile, "%s ^%c ", |
| 1325 |
m->m_name, s[i] + 'A' - 1); |
| 1326 |
if (i % 5 == 0) |
| 1327 |
(void) fprintf(el->el_errfile, "\n"); |
| 1328 |
} |
| 1329 |
(void) fprintf(el->el_errfile, "\n"); |
| 1330 |
} |
| 1331 |
#endif /* notyet */ |
| 1332 |
|
| 1333 |
|
| 1334 |
static void |
| 1335 |
tty_setup_flags(EditLine *el, struct termios *tios, int mode) |
| 1336 |
{ |
| 1337 |
int kind; |
| 1338 |
for (kind = MD_INP; kind <= MD_LIN; kind++) { |
| 1339 |
tcflag_t *f = tty__get_flag(tios, kind); |
| 1340 |
*f = tty_update_flag(el, *f, mode, kind); |
| 1341 |
} |
| 1342 |
} |