| 1 |
/* $NetBSD: terminal.c,v 1.32 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[] = "@(#)term.c 8.2 (Berkeley) 4/30/95"; |
| 39 |
#else |
| 40 |
__RCSID("$NetBSD: terminal.c,v 1.32 2016/05/09 21:46:56 christos Exp $"); |
| 41 |
#endif |
| 42 |
#endif /* not lint && not SCCSID */ |
| 43 |
|
| 44 |
/* |
| 45 |
* terminal.c: Editor/termcap-curses interface |
| 46 |
* We have to declare a static variable here, since the |
| 47 |
* termcap putchar routine does not take an argument! |
| 48 |
*/ |
| 49 |
#include <sys/types.h> |
| 50 |
#include <sys/ioctl.h> |
| 51 |
#include <limits.h> |
| 52 |
#include <signal.h> |
| 53 |
#include <stdio.h> |
| 54 |
#include <stdlib.h> |
| 55 |
#include <string.h> |
| 56 |
#include <unistd.h> |
| 57 |
#ifdef HAVE_TERMCAP_H |
| 58 |
#include <termcap.h> |
| 59 |
#endif |
| 60 |
#ifdef HAVE_CURSES_H |
| 61 |
#include <curses.h> |
| 62 |
#elif HAVE_NCURSES_H |
| 63 |
#include <ncurses.h> |
| 64 |
#endif |
| 65 |
|
| 66 |
/* Solaris's term.h does horrid things. */ |
| 67 |
#if defined(HAVE_TERM_H) && !defined(__sun) && !defined(HAVE_TERMCAP_H) |
| 68 |
#include <term.h> |
| 69 |
#endif |
| 70 |
|
| 71 |
#ifdef _REENTRANT |
| 72 |
#include <pthread.h> |
| 73 |
#endif |
| 74 |
|
| 75 |
#include "el.h" |
| 76 |
#include "fcns.h" |
| 77 |
|
| 78 |
/* |
| 79 |
* IMPORTANT NOTE: these routines are allowed to look at the current screen |
| 80 |
* and the current position assuming that it is correct. If this is not |
| 81 |
* true, then the update will be WRONG! This is (should be) a valid |
| 82 |
* assumption... |
| 83 |
*/ |
| 84 |
|
| 85 |
#define TC_BUFSIZE ((size_t)2048) |
| 86 |
|
| 87 |
#define GoodStr(a) (el->el_terminal.t_str[a] != NULL && \ |
| 88 |
el->el_terminal.t_str[a][0] != '\0') |
| 89 |
#define Str(a) el->el_terminal.t_str[a] |
| 90 |
#define Val(a) el->el_terminal.t_val[a] |
| 91 |
|
| 92 |
static const struct termcapstr { |
| 93 |
const char *name; |
| 94 |
const char *long_name; |
| 95 |
} tstr[] = { |
| 96 |
#define T_al 0 |
| 97 |
{ "al", "add new blank line" }, |
| 98 |
#define T_bl 1 |
| 99 |
{ "bl", "audible bell" }, |
| 100 |
#define T_cd 2 |
| 101 |
{ "cd", "clear to bottom" }, |
| 102 |
#define T_ce 3 |
| 103 |
{ "ce", "clear to end of line" }, |
| 104 |
#define T_ch 4 |
| 105 |
{ "ch", "cursor to horiz pos" }, |
| 106 |
#define T_cl 5 |
| 107 |
{ "cl", "clear screen" }, |
| 108 |
#define T_dc 6 |
| 109 |
{ "dc", "delete a character" }, |
| 110 |
#define T_dl 7 |
| 111 |
{ "dl", "delete a line" }, |
| 112 |
#define T_dm 8 |
| 113 |
{ "dm", "start delete mode" }, |
| 114 |
#define T_ed 9 |
| 115 |
{ "ed", "end delete mode" }, |
| 116 |
#define T_ei 10 |
| 117 |
{ "ei", "end insert mode" }, |
| 118 |
#define T_fs 11 |
| 119 |
{ "fs", "cursor from status line" }, |
| 120 |
#define T_ho 12 |
| 121 |
{ "ho", "home cursor" }, |
| 122 |
#define T_ic 13 |
| 123 |
{ "ic", "insert character" }, |
| 124 |
#define T_im 14 |
| 125 |
{ "im", "start insert mode" }, |
| 126 |
#define T_ip 15 |
| 127 |
{ "ip", "insert padding" }, |
| 128 |
#define T_kd 16 |
| 129 |
{ "kd", "sends cursor down" }, |
| 130 |
#define T_kl 17 |
| 131 |
{ "kl", "sends cursor left" }, |
| 132 |
#define T_kr 18 |
| 133 |
{ "kr", "sends cursor right" }, |
| 134 |
#define T_ku 19 |
| 135 |
{ "ku", "sends cursor up" }, |
| 136 |
#define T_md 20 |
| 137 |
{ "md", "begin bold" }, |
| 138 |
#define T_me 21 |
| 139 |
{ "me", "end attributes" }, |
| 140 |
#define T_nd 22 |
| 141 |
{ "nd", "non destructive space" }, |
| 142 |
#define T_se 23 |
| 143 |
{ "se", "end standout" }, |
| 144 |
#define T_so 24 |
| 145 |
{ "so", "begin standout" }, |
| 146 |
#define T_ts 25 |
| 147 |
{ "ts", "cursor to status line" }, |
| 148 |
#define T_up 26 |
| 149 |
{ "up", "cursor up one" }, |
| 150 |
#define T_us 27 |
| 151 |
{ "us", "begin underline" }, |
| 152 |
#define T_ue 28 |
| 153 |
{ "ue", "end underline" }, |
| 154 |
#define T_vb 29 |
| 155 |
{ "vb", "visible bell" }, |
| 156 |
#define T_DC 30 |
| 157 |
{ "DC", "delete multiple chars" }, |
| 158 |
#define T_DO 31 |
| 159 |
{ "DO", "cursor down multiple" }, |
| 160 |
#define T_IC 32 |
| 161 |
{ "IC", "insert multiple chars" }, |
| 162 |
#define T_LE 33 |
| 163 |
{ "LE", "cursor left multiple" }, |
| 164 |
#define T_RI 34 |
| 165 |
{ "RI", "cursor right multiple" }, |
| 166 |
#define T_UP 35 |
| 167 |
{ "UP", "cursor up multiple" }, |
| 168 |
#define T_kh 36 |
| 169 |
{ "kh", "send cursor home" }, |
| 170 |
#define T_at7 37 |
| 171 |
{ "@7", "send cursor end" }, |
| 172 |
#define T_kD 38 |
| 173 |
{ "kD", "send cursor delete" }, |
| 174 |
#define T_str 39 |
| 175 |
{ NULL, NULL } |
| 176 |
}; |
| 177 |
|
| 178 |
static const struct termcapval { |
| 179 |
const char *name; |
| 180 |
const char *long_name; |
| 181 |
} tval[] = { |
| 182 |
#define T_am 0 |
| 183 |
{ "am", "has automatic margins" }, |
| 184 |
#define T_pt 1 |
| 185 |
{ "pt", "has physical tabs" }, |
| 186 |
#define T_li 2 |
| 187 |
{ "li", "Number of lines" }, |
| 188 |
#define T_co 3 |
| 189 |
{ "co", "Number of columns" }, |
| 190 |
#define T_km 4 |
| 191 |
{ "km", "Has meta key" }, |
| 192 |
#define T_xt 5 |
| 193 |
{ "xt", "Tab chars destructive" }, |
| 194 |
#define T_xn 6 |
| 195 |
{ "xn", "newline ignored at right margin" }, |
| 196 |
#define T_MT 7 |
| 197 |
{ "MT", "Has meta key" }, /* XXX? */ |
| 198 |
#define T_val 8 |
| 199 |
{ NULL, NULL, } |
| 200 |
}; |
| 201 |
/* do two or more of the attributes use me */ |
| 202 |
|
| 203 |
static void terminal_setflags(EditLine *); |
| 204 |
static int terminal_rebuffer_display(EditLine *); |
| 205 |
static void terminal_free_display(EditLine *); |
| 206 |
static int terminal_alloc_display(EditLine *); |
| 207 |
static void terminal_alloc(EditLine *, const struct termcapstr *, |
| 208 |
const char *); |
| 209 |
static void terminal_init_arrow(EditLine *); |
| 210 |
static void terminal_reset_arrow(EditLine *); |
| 211 |
static int terminal_putc(int); |
| 212 |
static void terminal_tputs(EditLine *, const char *, int); |
| 213 |
|
| 214 |
#ifdef _REENTRANT |
| 215 |
static pthread_mutex_t terminal_mutex = PTHREAD_MUTEX_INITIALIZER; |
| 216 |
#endif |
| 217 |
static FILE *terminal_outfile = NULL; |
| 218 |
|
| 219 |
|
| 220 |
/* terminal_setflags(): |
| 221 |
* Set the terminal capability flags |
| 222 |
*/ |
| 223 |
static void |
| 224 |
terminal_setflags(EditLine *el) |
| 225 |
{ |
| 226 |
EL_FLAGS = 0; |
| 227 |
if (el->el_tty.t_tabs) |
| 228 |
EL_FLAGS |= (Val(T_pt) && !Val(T_xt)) ? TERM_CAN_TAB : 0; |
| 229 |
|
| 230 |
EL_FLAGS |= (Val(T_km) || Val(T_MT)) ? TERM_HAS_META : 0; |
| 231 |
EL_FLAGS |= GoodStr(T_ce) ? TERM_CAN_CEOL : 0; |
| 232 |
EL_FLAGS |= (GoodStr(T_dc) || GoodStr(T_DC)) ? TERM_CAN_DELETE : 0; |
| 233 |
EL_FLAGS |= (GoodStr(T_im) || GoodStr(T_ic) || GoodStr(T_IC)) ? |
| 234 |
TERM_CAN_INSERT : 0; |
| 235 |
EL_FLAGS |= (GoodStr(T_up) || GoodStr(T_UP)) ? TERM_CAN_UP : 0; |
| 236 |
EL_FLAGS |= Val(T_am) ? TERM_HAS_AUTO_MARGINS : 0; |
| 237 |
EL_FLAGS |= Val(T_xn) ? TERM_HAS_MAGIC_MARGINS : 0; |
| 238 |
|
| 239 |
if (GoodStr(T_me) && GoodStr(T_ue)) |
| 240 |
EL_FLAGS |= (strcmp(Str(T_me), Str(T_ue)) == 0) ? |
| 241 |
TERM_CAN_ME : 0; |
| 242 |
else |
| 243 |
EL_FLAGS &= ~TERM_CAN_ME; |
| 244 |
if (GoodStr(T_me) && GoodStr(T_se)) |
| 245 |
EL_FLAGS |= (strcmp(Str(T_me), Str(T_se)) == 0) ? |
| 246 |
TERM_CAN_ME : 0; |
| 247 |
|
| 248 |
|
| 249 |
#ifdef DEBUG_SCREEN |
| 250 |
if (!EL_CAN_UP) { |
| 251 |
(void) fprintf(el->el_errfile, |
| 252 |
"WARNING: Your terminal cannot move up.\n"); |
| 253 |
(void) fprintf(el->el_errfile, |
| 254 |
"Editing may be odd for long lines.\n"); |
| 255 |
} |
| 256 |
if (!EL_CAN_CEOL) |
| 257 |
(void) fprintf(el->el_errfile, "no clear EOL capability.\n"); |
| 258 |
if (!EL_CAN_DELETE) |
| 259 |
(void) fprintf(el->el_errfile, "no delete char capability.\n"); |
| 260 |
if (!EL_CAN_INSERT) |
| 261 |
(void) fprintf(el->el_errfile, "no insert char capability.\n"); |
| 262 |
#endif /* DEBUG_SCREEN */ |
| 263 |
} |
| 264 |
|
| 265 |
/* terminal_init(): |
| 266 |
* Initialize the terminal stuff |
| 267 |
*/ |
| 268 |
libedit_private int |
| 269 |
terminal_init(EditLine *el) |
| 270 |
{ |
| 271 |
|
| 272 |
el->el_terminal.t_buf = el_malloc(TC_BUFSIZE * |
| 273 |
sizeof(*el->el_terminal.t_buf)); |
| 274 |
if (el->el_terminal.t_buf == NULL) |
| 275 |
goto fail1; |
| 276 |
el->el_terminal.t_cap = el_malloc(TC_BUFSIZE * |
| 277 |
sizeof(*el->el_terminal.t_cap)); |
| 278 |
if (el->el_terminal.t_cap == NULL) |
| 279 |
goto fail2; |
| 280 |
el->el_terminal.t_fkey = el_malloc(A_K_NKEYS * |
| 281 |
sizeof(*el->el_terminal.t_fkey)); |
| 282 |
if (el->el_terminal.t_fkey == NULL) |
| 283 |
goto fail3; |
| 284 |
el->el_terminal.t_loc = 0; |
| 285 |
el->el_terminal.t_str = el_malloc(T_str * |
| 286 |
sizeof(*el->el_terminal.t_str)); |
| 287 |
if (el->el_terminal.t_str == NULL) |
| 288 |
goto fail4; |
| 289 |
(void) memset(el->el_terminal.t_str, 0, T_str * |
| 290 |
sizeof(*el->el_terminal.t_str)); |
| 291 |
el->el_terminal.t_val = el_malloc(T_val * |
| 292 |
sizeof(*el->el_terminal.t_val)); |
| 293 |
if (el->el_terminal.t_val == NULL) |
| 294 |
goto fail5; |
| 295 |
(void) memset(el->el_terminal.t_val, 0, T_val * |
| 296 |
sizeof(*el->el_terminal.t_val)); |
| 297 |
(void) terminal_set(el, NULL); |
| 298 |
terminal_init_arrow(el); |
| 299 |
return 0; |
| 300 |
fail5: |
| 301 |
free(el->el_terminal.t_str); |
| 302 |
el->el_terminal.t_str = NULL; |
| 303 |
fail4: |
| 304 |
free(el->el_terminal.t_fkey); |
| 305 |
el->el_terminal.t_fkey = NULL; |
| 306 |
fail3: |
| 307 |
free(el->el_terminal.t_cap); |
| 308 |
el->el_terminal.t_cap = NULL; |
| 309 |
fail2: |
| 310 |
free(el->el_terminal.t_buf); |
| 311 |
el->el_terminal.t_buf = NULL; |
| 312 |
fail1: |
| 313 |
return -1; |
| 314 |
} |
| 315 |
|
| 316 |
/* terminal_end(): |
| 317 |
* Clean up the terminal stuff |
| 318 |
*/ |
| 319 |
libedit_private void |
| 320 |
terminal_end(EditLine *el) |
| 321 |
{ |
| 322 |
|
| 323 |
el_free(el->el_terminal.t_buf); |
| 324 |
el->el_terminal.t_buf = NULL; |
| 325 |
el_free(el->el_terminal.t_cap); |
| 326 |
el->el_terminal.t_cap = NULL; |
| 327 |
el->el_terminal.t_loc = 0; |
| 328 |
el_free(el->el_terminal.t_str); |
| 329 |
el->el_terminal.t_str = NULL; |
| 330 |
el_free(el->el_terminal.t_val); |
| 331 |
el->el_terminal.t_val = NULL; |
| 332 |
el_free(el->el_terminal.t_fkey); |
| 333 |
el->el_terminal.t_fkey = NULL; |
| 334 |
terminal_free_display(el); |
| 335 |
} |
| 336 |
|
| 337 |
|
| 338 |
/* terminal_alloc(): |
| 339 |
* Maintain a string pool for termcap strings |
| 340 |
*/ |
| 341 |
static void |
| 342 |
terminal_alloc(EditLine *el, const struct termcapstr *t, const char *cap) |
| 343 |
{ |
| 344 |
char termbuf[TC_BUFSIZE]; |
| 345 |
size_t tlen, clen; |
| 346 |
char **tlist = el->el_terminal.t_str; |
| 347 |
char **tmp, **str = &tlist[t - tstr]; |
| 348 |
|
| 349 |
(void) memset(termbuf, 0, sizeof(termbuf)); |
| 350 |
if (cap == NULL || *cap == '\0') { |
| 351 |
*str = NULL; |
| 352 |
return; |
| 353 |
} else |
| 354 |
clen = strlen(cap); |
| 355 |
|
| 356 |
tlen = *str == NULL ? 0 : strlen(*str); |
| 357 |
|
| 358 |
/* |
| 359 |
* New string is shorter; no need to allocate space |
| 360 |
*/ |
| 361 |
if (clen <= tlen) { |
| 362 |
if (*str) |
| 363 |
(void) strcpy(*str, cap); /* XXX strcpy is safe */ |
| 364 |
return; |
| 365 |
} |
| 366 |
/* |
| 367 |
* New string is longer; see if we have enough space to append |
| 368 |
*/ |
| 369 |
if (el->el_terminal.t_loc + 3 < TC_BUFSIZE) { |
| 370 |
/* XXX strcpy is safe */ |
| 371 |
(void) strcpy(*str = &el->el_terminal.t_buf[ |
| 372 |
el->el_terminal.t_loc], cap); |
| 373 |
el->el_terminal.t_loc += clen + 1; /* one for \0 */ |
| 374 |
return; |
| 375 |
} |
| 376 |
/* |
| 377 |
* Compact our buffer; no need to check compaction, cause we know it |
| 378 |
* fits... |
| 379 |
*/ |
| 380 |
tlen = 0; |
| 381 |
for (tmp = tlist; tmp < &tlist[T_str]; tmp++) |
| 382 |
if (*tmp != NULL && **tmp != '\0' && *tmp != *str) { |
| 383 |
char *ptr; |
| 384 |
|
| 385 |
for (ptr = *tmp; *ptr != '\0'; termbuf[tlen++] = *ptr++) |
| 386 |
continue; |
| 387 |
termbuf[tlen++] = '\0'; |
| 388 |
} |
| 389 |
memcpy(el->el_terminal.t_buf, termbuf, TC_BUFSIZE); |
| 390 |
el->el_terminal.t_loc = tlen; |
| 391 |
if (el->el_terminal.t_loc + 3 >= TC_BUFSIZE) { |
| 392 |
(void) fprintf(el->el_errfile, |
| 393 |
"Out of termcap string space.\n"); |
| 394 |
return; |
| 395 |
} |
| 396 |
/* XXX strcpy is safe */ |
| 397 |
(void) strcpy(*str = &el->el_terminal.t_buf[el->el_terminal.t_loc], |
| 398 |
cap); |
| 399 |
el->el_terminal.t_loc += (size_t)clen + 1; /* one for \0 */ |
| 400 |
return; |
| 401 |
} |
| 402 |
|
| 403 |
|
| 404 |
/* terminal_rebuffer_display(): |
| 405 |
* Rebuffer the display after the screen changed size |
| 406 |
*/ |
| 407 |
static int |
| 408 |
terminal_rebuffer_display(EditLine *el) |
| 409 |
{ |
| 410 |
coord_t *c = &el->el_terminal.t_size; |
| 411 |
|
| 412 |
terminal_free_display(el); |
| 413 |
|
| 414 |
c->h = Val(T_co); |
| 415 |
c->v = Val(T_li); |
| 416 |
|
| 417 |
if (terminal_alloc_display(el) == -1) |
| 418 |
return -1; |
| 419 |
return 0; |
| 420 |
} |
| 421 |
|
| 422 |
|
| 423 |
/* terminal_alloc_display(): |
| 424 |
* Allocate a new display. |
| 425 |
*/ |
| 426 |
static int |
| 427 |
terminal_alloc_display(EditLine *el) |
| 428 |
{ |
| 429 |
int i; |
| 430 |
wchar_t **b; |
| 431 |
coord_t *c = &el->el_terminal.t_size; |
| 432 |
|
| 433 |
b = el_malloc(sizeof(*b) * (size_t)(c->v + 1)); |
| 434 |
if (b == NULL) |
| 435 |
goto done; |
| 436 |
for (i = 0; i < c->v; i++) { |
| 437 |
b[i] = el_malloc(sizeof(**b) * (size_t)(c->h + 1)); |
| 438 |
if (b[i] == NULL) { |
| 439 |
while (--i >= 0) |
| 440 |
el_free(b[i]); |
| 441 |
el_free(b); |
| 442 |
goto done; |
| 443 |
} |
| 444 |
} |
| 445 |
b[c->v] = NULL; |
| 446 |
el->el_display = b; |
| 447 |
|
| 448 |
b = el_malloc(sizeof(*b) * (size_t)(c->v + 1)); |
| 449 |
if (b == NULL) |
| 450 |
goto done; |
| 451 |
for (i = 0; i < c->v; i++) { |
| 452 |
b[i] = el_malloc(sizeof(**b) * (size_t)(c->h + 1)); |
| 453 |
if (b[i] == NULL) { |
| 454 |
while (--i >= 0) |
| 455 |
el_free(b[i]); |
| 456 |
el_free(b); |
| 457 |
goto done; |
| 458 |
} |
| 459 |
} |
| 460 |
b[c->v] = NULL; |
| 461 |
el->el_vdisplay = b; |
| 462 |
return 0; |
| 463 |
done: |
| 464 |
terminal_free_display(el); |
| 465 |
return -1; |
| 466 |
} |
| 467 |
|
| 468 |
|
| 469 |
/* terminal_free_display(): |
| 470 |
* Free the display buffers |
| 471 |
*/ |
| 472 |
static void |
| 473 |
terminal_free_display(EditLine *el) |
| 474 |
{ |
| 475 |
wchar_t **b; |
| 476 |
wchar_t **bufp; |
| 477 |
|
| 478 |
b = el->el_display; |
| 479 |
el->el_display = NULL; |
| 480 |
if (b != NULL) { |
| 481 |
for (bufp = b; *bufp != NULL; bufp++) |
| 482 |
el_free(*bufp); |
| 483 |
el_free(b); |
| 484 |
} |
| 485 |
b = el->el_vdisplay; |
| 486 |
el->el_vdisplay = NULL; |
| 487 |
if (b != NULL) { |
| 488 |
for (bufp = b; *bufp != NULL; bufp++) |
| 489 |
el_free(*bufp); |
| 490 |
el_free(b); |
| 491 |
} |
| 492 |
} |
| 493 |
|
| 494 |
|
| 495 |
/* terminal_move_to_line(): |
| 496 |
* move to line <where> (first line == 0) |
| 497 |
* as efficiently as possible |
| 498 |
*/ |
| 499 |
libedit_private void |
| 500 |
terminal_move_to_line(EditLine *el, int where) |
| 501 |
{ |
| 502 |
int del; |
| 503 |
|
| 504 |
if (where == el->el_cursor.v) |
| 505 |
return; |
| 506 |
|
| 507 |
if (where > el->el_terminal.t_size.v) { |
| 508 |
#ifdef DEBUG_SCREEN |
| 509 |
(void) fprintf(el->el_errfile, |
| 510 |
"%s: where is ridiculous: %d\r\n", __func__, where); |
| 511 |
#endif /* DEBUG_SCREEN */ |
| 512 |
return; |
| 513 |
} |
| 514 |
if ((del = where - el->el_cursor.v) > 0) { |
| 515 |
while (del > 0) { |
| 516 |
if (EL_HAS_AUTO_MARGINS && |
| 517 |
el->el_display[el->el_cursor.v][0] != '\0') { |
| 518 |
size_t h = (size_t) |
| 519 |
(el->el_terminal.t_size.h - 1); |
| 520 |
for (; h > 0 && |
| 521 |
el->el_display[el->el_cursor.v][h] == |
| 522 |
MB_FILL_CHAR; |
| 523 |
h--) |
| 524 |
continue; |
| 525 |
/* move without newline */ |
| 526 |
terminal_move_to_char(el, (int)h); |
| 527 |
terminal_overwrite(el, &el->el_display |
| 528 |
[el->el_cursor.v][el->el_cursor.h], |
| 529 |
(size_t)(el->el_terminal.t_size.h - |
| 530 |
el->el_cursor.h)); |
| 531 |
/* updates Cursor */ |
| 532 |
del--; |
| 533 |
} else { |
| 534 |
if ((del > 1) && GoodStr(T_DO)) { |
| 535 |
terminal_tputs(el, tgoto(Str(T_DO), del, |
| 536 |
del), del); |
| 537 |
del = 0; |
| 538 |
} else { |
| 539 |
for (; del > 0; del--) |
| 540 |
terminal__putc(el, '\n'); |
| 541 |
/* because the \n will become \r\n */ |
| 542 |
el->el_cursor.h = 0; |
| 543 |
} |
| 544 |
} |
| 545 |
} |
| 546 |
} else { /* del < 0 */ |
| 547 |
if (GoodStr(T_UP) && (-del > 1 || !GoodStr(T_up))) |
| 548 |
terminal_tputs(el, tgoto(Str(T_UP), -del, -del), -del); |
| 549 |
else { |
| 550 |
if (GoodStr(T_up)) |
| 551 |
for (; del < 0; del++) |
| 552 |
terminal_tputs(el, Str(T_up), 1); |
| 553 |
} |
| 554 |
} |
| 555 |
el->el_cursor.v = where;/* now where is here */ |
| 556 |
} |
| 557 |
|
| 558 |
|
| 559 |
/* terminal_move_to_char(): |
| 560 |
* Move to the character position specified |
| 561 |
*/ |
| 562 |
libedit_private void |
| 563 |
terminal_move_to_char(EditLine *el, int where) |
| 564 |
{ |
| 565 |
int del, i; |
| 566 |
|
| 567 |
mc_again: |
| 568 |
if (where == el->el_cursor.h) |
| 569 |
return; |
| 570 |
|
| 571 |
if (where > el->el_terminal.t_size.h) { |
| 572 |
#ifdef DEBUG_SCREEN |
| 573 |
(void) fprintf(el->el_errfile, |
| 574 |
"%s: where is ridiculous: %d\r\n", __func__, where); |
| 575 |
#endif /* DEBUG_SCREEN */ |
| 576 |
return; |
| 577 |
} |
| 578 |
if (!where) { /* if where is first column */ |
| 579 |
terminal__putc(el, '\r'); /* do a CR */ |
| 580 |
el->el_cursor.h = 0; |
| 581 |
return; |
| 582 |
} |
| 583 |
del = where - el->el_cursor.h; |
| 584 |
|
| 585 |
if ((del < -4 || del > 4) && GoodStr(T_ch)) |
| 586 |
/* go there directly */ |
| 587 |
terminal_tputs(el, tgoto(Str(T_ch), where, where), where); |
| 588 |
else { |
| 589 |
if (del > 0) { /* moving forward */ |
| 590 |
if ((del > 4) && GoodStr(T_RI)) |
| 591 |
terminal_tputs(el, tgoto(Str(T_RI), del, del), |
| 592 |
del); |
| 593 |
else { |
| 594 |
/* if I can do tabs, use them */ |
| 595 |
if (EL_CAN_TAB) { |
| 596 |
if ((el->el_cursor.h & 0370) != |
| 597 |
(where & ~0x7) |
| 598 |
&& (el->el_display[ |
| 599 |
el->el_cursor.v][where & 0370] != |
| 600 |
MB_FILL_CHAR) |
| 601 |
) { |
| 602 |
/* if not within tab stop */ |
| 603 |
for (i = |
| 604 |
(el->el_cursor.h & 0370); |
| 605 |
i < (where & ~0x7); |
| 606 |
i += 8) |
| 607 |
terminal__putc(el, |
| 608 |
'\t'); |
| 609 |
/* then tab over */ |
| 610 |
el->el_cursor.h = where & ~0x7; |
| 611 |
} |
| 612 |
} |
| 613 |
/* |
| 614 |
* it's usually cheaper to just write the |
| 615 |
* chars, so we do. |
| 616 |
*/ |
| 617 |
/* |
| 618 |
* NOTE THAT terminal_overwrite() WILL CHANGE |
| 619 |
* el->el_cursor.h!!! |
| 620 |
*/ |
| 621 |
terminal_overwrite(el, &el->el_display[ |
| 622 |
el->el_cursor.v][el->el_cursor.h], |
| 623 |
(size_t)(where - el->el_cursor.h)); |
| 624 |
|
| 625 |
} |
| 626 |
} else { /* del < 0 := moving backward */ |
| 627 |
if ((-del > 4) && GoodStr(T_LE)) |
| 628 |
terminal_tputs(el, tgoto(Str(T_LE), -del, -del), |
| 629 |
-del); |
| 630 |
else { /* can't go directly there */ |
| 631 |
/* |
| 632 |
* if the "cost" is greater than the "cost" |
| 633 |
* from col 0 |
| 634 |
*/ |
| 635 |
if (EL_CAN_TAB ? |
| 636 |
((unsigned int)-del > |
| 637 |
(((unsigned int) where >> 3) + |
| 638 |
(where & 07))) |
| 639 |
: (-del > where)) { |
| 640 |
terminal__putc(el, '\r');/* do a CR */ |
| 641 |
el->el_cursor.h = 0; |
| 642 |
goto mc_again; /* and try again */ |
| 643 |
} |
| 644 |
for (i = 0; i < -del; i++) |
| 645 |
terminal__putc(el, '\b'); |
| 646 |
} |
| 647 |
} |
| 648 |
} |
| 649 |
el->el_cursor.h = where; /* now where is here */ |
| 650 |
} |
| 651 |
|
| 652 |
|
| 653 |
/* terminal_overwrite(): |
| 654 |
* Overstrike num characters |
| 655 |
* Assumes MB_FILL_CHARs are present to keep the column count correct |
| 656 |
*/ |
| 657 |
libedit_private void |
| 658 |
terminal_overwrite(EditLine *el, const wchar_t *cp, size_t n) |
| 659 |
{ |
| 660 |
if (n == 0) |
| 661 |
return; |
| 662 |
|
| 663 |
if (n > (size_t)el->el_terminal.t_size.h) { |
| 664 |
#ifdef DEBUG_SCREEN |
| 665 |
(void) fprintf(el->el_errfile, |
| 666 |
"%s: n is ridiculous: %zu\r\n", __func__, n); |
| 667 |
#endif /* DEBUG_SCREEN */ |
| 668 |
return; |
| 669 |
} |
| 670 |
|
| 671 |
do { |
| 672 |
/* terminal__putc() ignores any MB_FILL_CHARs */ |
| 673 |
terminal__putc(el, *cp++); |
| 674 |
el->el_cursor.h++; |
| 675 |
} while (--n); |
| 676 |
|
| 677 |
if (el->el_cursor.h >= el->el_terminal.t_size.h) { /* wrap? */ |
| 678 |
if (EL_HAS_AUTO_MARGINS) { /* yes */ |
| 679 |
el->el_cursor.h = 0; |
| 680 |
el->el_cursor.v++; |
| 681 |
if (EL_HAS_MAGIC_MARGINS) { |
| 682 |
/* force the wrap to avoid the "magic" |
| 683 |
* situation */ |
| 684 |
wchar_t c; |
| 685 |
if ((c = el->el_display[el->el_cursor.v] |
| 686 |
[el->el_cursor.h]) != '\0') { |
| 687 |
terminal_overwrite(el, &c, (size_t)1); |
| 688 |
while (el->el_display[el->el_cursor.v] |
| 689 |
[el->el_cursor.h] == MB_FILL_CHAR) |
| 690 |
el->el_cursor.h++; |
| 691 |
} else { |
| 692 |
terminal__putc(el, ' '); |
| 693 |
el->el_cursor.h = 1; |
| 694 |
} |
| 695 |
} |
| 696 |
} else /* no wrap, but cursor stays on screen */ |
| 697 |
el->el_cursor.h = el->el_terminal.t_size.h - 1; |
| 698 |
} |
| 699 |
} |
| 700 |
|
| 701 |
|
| 702 |
/* terminal_deletechars(): |
| 703 |
* Delete num characters |
| 704 |
*/ |
| 705 |
libedit_private void |
| 706 |
terminal_deletechars(EditLine *el, int num) |
| 707 |
{ |
| 708 |
if (num <= 0) |
| 709 |
return; |
| 710 |
|
| 711 |
if (!EL_CAN_DELETE) { |
| 712 |
#ifdef DEBUG_EDIT |
| 713 |
(void) fprintf(el->el_errfile, " ERROR: cannot delete \n"); |
| 714 |
#endif /* DEBUG_EDIT */ |
| 715 |
return; |
| 716 |
} |
| 717 |
if (num > el->el_terminal.t_size.h) { |
| 718 |
#ifdef DEBUG_SCREEN |
| 719 |
(void) fprintf(el->el_errfile, |
| 720 |
"%s: num is ridiculous: %d\r\n", __func__, num); |
| 721 |
#endif /* DEBUG_SCREEN */ |
| 722 |
return; |
| 723 |
} |
| 724 |
if (GoodStr(T_DC)) /* if I have multiple delete */ |
| 725 |
if ((num > 1) || !GoodStr(T_dc)) { /* if dc would be more |
| 726 |
* expen. */ |
| 727 |
terminal_tputs(el, tgoto(Str(T_DC), num, num), num); |
| 728 |
return; |
| 729 |
} |
| 730 |
if (GoodStr(T_dm)) /* if I have delete mode */ |
| 731 |
terminal_tputs(el, Str(T_dm), 1); |
| 732 |
|
| 733 |
if (GoodStr(T_dc)) /* else do one at a time */ |
| 734 |
while (num--) |
| 735 |
terminal_tputs(el, Str(T_dc), 1); |
| 736 |
|
| 737 |
if (GoodStr(T_ed)) /* if I have delete mode */ |
| 738 |
terminal_tputs(el, Str(T_ed), 1); |
| 739 |
} |
| 740 |
|
| 741 |
|
| 742 |
/* terminal_insertwrite(): |
| 743 |
* Puts terminal in insert character mode or inserts num |
| 744 |
* characters in the line |
| 745 |
* Assumes MB_FILL_CHARs are present to keep column count correct |
| 746 |
*/ |
| 747 |
libedit_private void |
| 748 |
terminal_insertwrite(EditLine *el, wchar_t *cp, int num) |
| 749 |
{ |
| 750 |
if (num <= 0) |
| 751 |
return; |
| 752 |
if (!EL_CAN_INSERT) { |
| 753 |
#ifdef DEBUG_EDIT |
| 754 |
(void) fprintf(el->el_errfile, " ERROR: cannot insert \n"); |
| 755 |
#endif /* DEBUG_EDIT */ |
| 756 |
return; |
| 757 |
} |
| 758 |
if (num > el->el_terminal.t_size.h) { |
| 759 |
#ifdef DEBUG_SCREEN |
| 760 |
(void) fprintf(el->el_errfile, |
| 761 |
"%s: num is ridiculous: %d\r\n", __func__, num); |
| 762 |
#endif /* DEBUG_SCREEN */ |
| 763 |
return; |
| 764 |
} |
| 765 |
if (GoodStr(T_IC)) /* if I have multiple insert */ |
| 766 |
if ((num > 1) || !GoodStr(T_ic)) { |
| 767 |
/* if ic would be more expensive */ |
| 768 |
terminal_tputs(el, tgoto(Str(T_IC), num, num), num); |
| 769 |
terminal_overwrite(el, cp, (size_t)num); |
| 770 |
/* this updates el_cursor.h */ |
| 771 |
return; |
| 772 |
} |
| 773 |
if (GoodStr(T_im) && GoodStr(T_ei)) { /* if I have insert mode */ |
| 774 |
terminal_tputs(el, Str(T_im), 1); |
| 775 |
|
| 776 |
el->el_cursor.h += num; |
| 777 |
do |
| 778 |
terminal__putc(el, *cp++); |
| 779 |
while (--num); |
| 780 |
|
| 781 |
if (GoodStr(T_ip)) /* have to make num chars insert */ |
| 782 |
terminal_tputs(el, Str(T_ip), 1); |
| 783 |
|
| 784 |
terminal_tputs(el, Str(T_ei), 1); |
| 785 |
return; |
| 786 |
} |
| 787 |
do { |
| 788 |
if (GoodStr(T_ic)) /* have to make num chars insert */ |
| 789 |
terminal_tputs(el, Str(T_ic), 1); |
| 790 |
|
| 791 |
terminal__putc(el, *cp++); |
| 792 |
|
| 793 |
el->el_cursor.h++; |
| 794 |
|
| 795 |
if (GoodStr(T_ip)) /* have to make num chars insert */ |
| 796 |
terminal_tputs(el, Str(T_ip), 1); |
| 797 |
/* pad the inserted char */ |
| 798 |
|
| 799 |
} while (--num); |
| 800 |
} |
| 801 |
|
| 802 |
|
| 803 |
/* terminal_clear_EOL(): |
| 804 |
* clear to end of line. There are num characters to clear |
| 805 |
*/ |
| 806 |
libedit_private void |
| 807 |
terminal_clear_EOL(EditLine *el, int num) |
| 808 |
{ |
| 809 |
int i; |
| 810 |
|
| 811 |
if (EL_CAN_CEOL && GoodStr(T_ce)) |
| 812 |
terminal_tputs(el, Str(T_ce), 1); |
| 813 |
else { |
| 814 |
for (i = 0; i < num; i++) |
| 815 |
terminal__putc(el, ' '); |
| 816 |
el->el_cursor.h += num; /* have written num spaces */ |
| 817 |
} |
| 818 |
} |
| 819 |
|
| 820 |
|
| 821 |
/* terminal_clear_screen(): |
| 822 |
* Clear the screen |
| 823 |
*/ |
| 824 |
libedit_private void |
| 825 |
terminal_clear_screen(EditLine *el) |
| 826 |
{ /* clear the whole screen and home */ |
| 827 |
|
| 828 |
if (GoodStr(T_cl)) |
| 829 |
/* send the clear screen code */ |
| 830 |
terminal_tputs(el, Str(T_cl), Val(T_li)); |
| 831 |
else if (GoodStr(T_ho) && GoodStr(T_cd)) { |
| 832 |
terminal_tputs(el, Str(T_ho), Val(T_li)); /* home */ |
| 833 |
/* clear to bottom of screen */ |
| 834 |
terminal_tputs(el, Str(T_cd), Val(T_li)); |
| 835 |
} else { |
| 836 |
terminal__putc(el, '\r'); |
| 837 |
terminal__putc(el, '\n'); |
| 838 |
} |
| 839 |
} |
| 840 |
|
| 841 |
|
| 842 |
/* terminal_beep(): |
| 843 |
* Beep the way the terminal wants us |
| 844 |
*/ |
| 845 |
libedit_private void |
| 846 |
terminal_beep(EditLine *el) |
| 847 |
{ |
| 848 |
if (GoodStr(T_bl)) |
| 849 |
/* what termcap says we should use */ |
| 850 |
terminal_tputs(el, Str(T_bl), 1); |
| 851 |
else |
| 852 |
terminal__putc(el, '\007'); /* an ASCII bell; ^G */ |
| 853 |
} |
| 854 |
|
| 855 |
|
| 856 |
libedit_private void |
| 857 |
terminal_get(EditLine *el, const char **term) |
| 858 |
{ |
| 859 |
*term = el->el_terminal.t_name; |
| 860 |
} |
| 861 |
|
| 862 |
|
| 863 |
/* terminal_set(): |
| 864 |
* Read in the terminal capabilities from the requested terminal |
| 865 |
*/ |
| 866 |
libedit_private int |
| 867 |
terminal_set(EditLine *el, const char *term) |
| 868 |
{ |
| 869 |
int i; |
| 870 |
char buf[TC_BUFSIZE]; |
| 871 |
char *area; |
| 872 |
const struct termcapstr *t; |
| 873 |
sigset_t oset, nset; |
| 874 |
int lins, cols; |
| 875 |
|
| 876 |
(void) sigemptyset(&nset); |
| 877 |
(void) sigaddset(&nset, SIGWINCH); |
| 878 |
(void) sigprocmask(SIG_BLOCK, &nset, &oset); |
| 879 |
|
| 880 |
area = buf; |
| 881 |
|
| 882 |
|
| 883 |
if (term == NULL) |
| 884 |
term = getenv("TERM"); |
| 885 |
|
| 886 |
if (!term || !term[0]) |
| 887 |
term = "dumb"; |
| 888 |
|
| 889 |
if (strcmp(term, "emacs") == 0) |
| 890 |
el->el_flags |= EDIT_DISABLED; |
| 891 |
|
| 892 |
(void) memset(el->el_terminal.t_cap, 0, TC_BUFSIZE); |
| 893 |
|
| 894 |
i = tgetent(el->el_terminal.t_cap, term); |
| 895 |
|
| 896 |
if (i <= 0) { |
| 897 |
if (i == -1) |
| 898 |
(void) fprintf(el->el_errfile, |
| 899 |
"Cannot read termcap database;\n"); |
| 900 |
else if (i == 0) |
| 901 |
(void) fprintf(el->el_errfile, |
| 902 |
"No entry for terminal type \"%s\";\n", term); |
| 903 |
(void) fprintf(el->el_errfile, |
| 904 |
"using dumb terminal settings.\n"); |
| 905 |
Val(T_co) = 80; /* do a dumb terminal */ |
| 906 |
Val(T_pt) = Val(T_km) = Val(T_li) = 0; |
| 907 |
Val(T_xt) = Val(T_MT); |
| 908 |
for (t = tstr; t->name != NULL; t++) |
| 909 |
terminal_alloc(el, t, NULL); |
| 910 |
} else { |
| 911 |
/* auto/magic margins */ |
| 912 |
Val(T_am) = tgetflag("am"); |
| 913 |
Val(T_xn) = tgetflag("xn"); |
| 914 |
/* Can we tab */ |
| 915 |
Val(T_pt) = tgetflag("pt"); |
| 916 |
Val(T_xt) = tgetflag("xt"); |
| 917 |
/* do we have a meta? */ |
| 918 |
Val(T_km) = tgetflag("km"); |
| 919 |
Val(T_MT) = tgetflag("MT"); |
| 920 |
/* Get the size */ |
| 921 |
Val(T_co) = tgetnum("co"); |
| 922 |
Val(T_li) = tgetnum("li"); |
| 923 |
for (t = tstr; t->name != NULL; t++) { |
| 924 |
/* XXX: some systems' tgetstr needs non const */ |
| 925 |
terminal_alloc(el, t, tgetstr(strchr(t->name, *t->name), |
| 926 |
&area)); |
| 927 |
} |
| 928 |
} |
| 929 |
|
| 930 |
if (Val(T_co) < 2) |
| 931 |
Val(T_co) = 80; /* just in case */ |
| 932 |
if (Val(T_li) < 1) |
| 933 |
Val(T_li) = 24; |
| 934 |
|
| 935 |
el->el_terminal.t_size.v = Val(T_co); |
| 936 |
el->el_terminal.t_size.h = Val(T_li); |
| 937 |
|
| 938 |
terminal_setflags(el); |
| 939 |
|
| 940 |
/* get the correct window size */ |
| 941 |
(void) terminal_get_size(el, &lins, &cols); |
| 942 |
if (terminal_change_size(el, lins, cols) == -1) |
| 943 |
return -1; |
| 944 |
(void) sigprocmask(SIG_SETMASK, &oset, NULL); |
| 945 |
terminal_bind_arrow(el); |
| 946 |
el->el_terminal.t_name = term; |
| 947 |
return i <= 0 ? -1 : 0; |
| 948 |
} |
| 949 |
|
| 950 |
|
| 951 |
/* terminal_get_size(): |
| 952 |
* Return the new window size in lines and cols, and |
| 953 |
* true if the size was changed. |
| 954 |
*/ |
| 955 |
libedit_private int |
| 956 |
terminal_get_size(EditLine *el, int *lins, int *cols) |
| 957 |
{ |
| 958 |
|
| 959 |
*cols = Val(T_co); |
| 960 |
*lins = Val(T_li); |
| 961 |
|
| 962 |
#ifdef TIOCGWINSZ |
| 963 |
{ |
| 964 |
struct winsize ws; |
| 965 |
if (ioctl(el->el_infd, TIOCGWINSZ, &ws) != -1) { |
| 966 |
if (ws.ws_col) |
| 967 |
*cols = ws.ws_col; |
| 968 |
if (ws.ws_row) |
| 969 |
*lins = ws.ws_row; |
| 970 |
} |
| 971 |
} |
| 972 |
#endif |
| 973 |
#ifdef TIOCGSIZE |
| 974 |
{ |
| 975 |
struct ttysize ts; |
| 976 |
if (ioctl(el->el_infd, TIOCGSIZE, &ts) != -1) { |
| 977 |
if (ts.ts_cols) |
| 978 |
*cols = ts.ts_cols; |
| 979 |
if (ts.ts_lines) |
| 980 |
*lins = ts.ts_lines; |
| 981 |
} |
| 982 |
} |
| 983 |
#endif |
| 984 |
return Val(T_co) != *cols || Val(T_li) != *lins; |
| 985 |
} |
| 986 |
|
| 987 |
|
| 988 |
/* terminal_change_size(): |
| 989 |
* Change the size of the terminal |
| 990 |
*/ |
| 991 |
libedit_private int |
| 992 |
terminal_change_size(EditLine *el, int lins, int cols) |
| 993 |
{ |
| 994 |
/* |
| 995 |
* Just in case |
| 996 |
*/ |
| 997 |
Val(T_co) = (cols < 2) ? 80 : cols; |
| 998 |
Val(T_li) = (lins < 1) ? 24 : lins; |
| 999 |
|
| 1000 |
/* re-make display buffers */ |
| 1001 |
if (terminal_rebuffer_display(el) == -1) |
| 1002 |
return -1; |
| 1003 |
re_clear_display(el); |
| 1004 |
return 0; |
| 1005 |
} |
| 1006 |
|
| 1007 |
|
| 1008 |
/* terminal_init_arrow(): |
| 1009 |
* Initialize the arrow key bindings from termcap |
| 1010 |
*/ |
| 1011 |
static void |
| 1012 |
terminal_init_arrow(EditLine *el) |
| 1013 |
{ |
| 1014 |
funckey_t *arrow = el->el_terminal.t_fkey; |
| 1015 |
|
| 1016 |
arrow[A_K_DN].name = L"down"; |
| 1017 |
arrow[A_K_DN].key = T_kd; |
| 1018 |
arrow[A_K_DN].fun.cmd = ED_NEXT_HISTORY; |
| 1019 |
arrow[A_K_DN].type = XK_CMD; |
| 1020 |
|
| 1021 |
arrow[A_K_UP].name = L"up"; |
| 1022 |
arrow[A_K_UP].key = T_ku; |
| 1023 |
arrow[A_K_UP].fun.cmd = ED_PREV_HISTORY; |
| 1024 |
arrow[A_K_UP].type = XK_CMD; |
| 1025 |
|
| 1026 |
arrow[A_K_LT].name = L"left"; |
| 1027 |
arrow[A_K_LT].key = T_kl; |
| 1028 |
arrow[A_K_LT].fun.cmd = ED_PREV_CHAR; |
| 1029 |
arrow[A_K_LT].type = XK_CMD; |
| 1030 |
|
| 1031 |
arrow[A_K_RT].name = L"right"; |
| 1032 |
arrow[A_K_RT].key = T_kr; |
| 1033 |
arrow[A_K_RT].fun.cmd = ED_NEXT_CHAR; |
| 1034 |
arrow[A_K_RT].type = XK_CMD; |
| 1035 |
|
| 1036 |
arrow[A_K_HO].name = L"home"; |
| 1037 |
arrow[A_K_HO].key = T_kh; |
| 1038 |
arrow[A_K_HO].fun.cmd = ED_MOVE_TO_BEG; |
| 1039 |
arrow[A_K_HO].type = XK_CMD; |
| 1040 |
|
| 1041 |
arrow[A_K_EN].name = L"end"; |
| 1042 |
arrow[A_K_EN].key = T_at7; |
| 1043 |
arrow[A_K_EN].fun.cmd = ED_MOVE_TO_END; |
| 1044 |
arrow[A_K_EN].type = XK_CMD; |
| 1045 |
|
| 1046 |
arrow[A_K_DE].name = L"delete"; |
| 1047 |
arrow[A_K_DE].key = T_kD; |
| 1048 |
arrow[A_K_DE].fun.cmd = ED_DELETE_NEXT_CHAR; |
| 1049 |
arrow[A_K_DE].type = XK_CMD; |
| 1050 |
} |
| 1051 |
|
| 1052 |
|
| 1053 |
/* terminal_reset_arrow(): |
| 1054 |
* Reset arrow key bindings |
| 1055 |
*/ |
| 1056 |
static void |
| 1057 |
terminal_reset_arrow(EditLine *el) |
| 1058 |
{ |
| 1059 |
funckey_t *arrow = el->el_terminal.t_fkey; |
| 1060 |
static const wchar_t strA[] = L"\033[A"; |
| 1061 |
static const wchar_t strB[] = L"\033[B"; |
| 1062 |
static const wchar_t strC[] = L"\033[C"; |
| 1063 |
static const wchar_t strD[] = L"\033[D"; |
| 1064 |
static const wchar_t strH[] = L"\033[H"; |
| 1065 |
static const wchar_t strF[] = L"\033[F"; |
| 1066 |
static const wchar_t stOA[] = L"\033OA"; |
| 1067 |
static const wchar_t stOB[] = L"\033OB"; |
| 1068 |
static const wchar_t stOC[] = L"\033OC"; |
| 1069 |
static const wchar_t stOD[] = L"\033OD"; |
| 1070 |
static const wchar_t stOH[] = L"\033OH"; |
| 1071 |
static const wchar_t stOF[] = L"\033OF"; |
| 1072 |
|
| 1073 |
keymacro_add(el, strA, &arrow[A_K_UP].fun, arrow[A_K_UP].type); |
| 1074 |
keymacro_add(el, strB, &arrow[A_K_DN].fun, arrow[A_K_DN].type); |
| 1075 |
keymacro_add(el, strC, &arrow[A_K_RT].fun, arrow[A_K_RT].type); |
| 1076 |
keymacro_add(el, strD, &arrow[A_K_LT].fun, arrow[A_K_LT].type); |
| 1077 |
keymacro_add(el, strH, &arrow[A_K_HO].fun, arrow[A_K_HO].type); |
| 1078 |
keymacro_add(el, strF, &arrow[A_K_EN].fun, arrow[A_K_EN].type); |
| 1079 |
keymacro_add(el, stOA, &arrow[A_K_UP].fun, arrow[A_K_UP].type); |
| 1080 |
keymacro_add(el, stOB, &arrow[A_K_DN].fun, arrow[A_K_DN].type); |
| 1081 |
keymacro_add(el, stOC, &arrow[A_K_RT].fun, arrow[A_K_RT].type); |
| 1082 |
keymacro_add(el, stOD, &arrow[A_K_LT].fun, arrow[A_K_LT].type); |
| 1083 |
keymacro_add(el, stOH, &arrow[A_K_HO].fun, arrow[A_K_HO].type); |
| 1084 |
keymacro_add(el, stOF, &arrow[A_K_EN].fun, arrow[A_K_EN].type); |
| 1085 |
|
| 1086 |
if (el->el_map.type != MAP_VI) |
| 1087 |
return; |
| 1088 |
keymacro_add(el, &strA[1], &arrow[A_K_UP].fun, arrow[A_K_UP].type); |
| 1089 |
keymacro_add(el, &strB[1], &arrow[A_K_DN].fun, arrow[A_K_DN].type); |
| 1090 |
keymacro_add(el, &strC[1], &arrow[A_K_RT].fun, arrow[A_K_RT].type); |
| 1091 |
keymacro_add(el, &strD[1], &arrow[A_K_LT].fun, arrow[A_K_LT].type); |
| 1092 |
keymacro_add(el, &strH[1], &arrow[A_K_HO].fun, arrow[A_K_HO].type); |
| 1093 |
keymacro_add(el, &strF[1], &arrow[A_K_EN].fun, arrow[A_K_EN].type); |
| 1094 |
keymacro_add(el, &stOA[1], &arrow[A_K_UP].fun, arrow[A_K_UP].type); |
| 1095 |
keymacro_add(el, &stOB[1], &arrow[A_K_DN].fun, arrow[A_K_DN].type); |
| 1096 |
keymacro_add(el, &stOC[1], &arrow[A_K_RT].fun, arrow[A_K_RT].type); |
| 1097 |
keymacro_add(el, &stOD[1], &arrow[A_K_LT].fun, arrow[A_K_LT].type); |
| 1098 |
keymacro_add(el, &stOH[1], &arrow[A_K_HO].fun, arrow[A_K_HO].type); |
| 1099 |
keymacro_add(el, &stOF[1], &arrow[A_K_EN].fun, arrow[A_K_EN].type); |
| 1100 |
} |
| 1101 |
|
| 1102 |
|
| 1103 |
/* terminal_set_arrow(): |
| 1104 |
* Set an arrow key binding |
| 1105 |
*/ |
| 1106 |
libedit_private int |
| 1107 |
terminal_set_arrow(EditLine *el, const wchar_t *name, keymacro_value_t *fun, |
| 1108 |
int type) |
| 1109 |
{ |
| 1110 |
funckey_t *arrow = el->el_terminal.t_fkey; |
| 1111 |
int i; |
| 1112 |
|
| 1113 |
for (i = 0; i < A_K_NKEYS; i++) |
| 1114 |
if (wcscmp(name, arrow[i].name) == 0) { |
| 1115 |
arrow[i].fun = *fun; |
| 1116 |
arrow[i].type = type; |
| 1117 |
return 0; |
| 1118 |
} |
| 1119 |
return -1; |
| 1120 |
} |
| 1121 |
|
| 1122 |
|
| 1123 |
/* terminal_clear_arrow(): |
| 1124 |
* Clear an arrow key binding |
| 1125 |
*/ |
| 1126 |
libedit_private int |
| 1127 |
terminal_clear_arrow(EditLine *el, const wchar_t *name) |
| 1128 |
{ |
| 1129 |
funckey_t *arrow = el->el_terminal.t_fkey; |
| 1130 |
int i; |
| 1131 |
|
| 1132 |
for (i = 0; i < A_K_NKEYS; i++) |
| 1133 |
if (wcscmp(name, arrow[i].name) == 0) { |
| 1134 |
arrow[i].type = XK_NOD; |
| 1135 |
return 0; |
| 1136 |
} |
| 1137 |
return -1; |
| 1138 |
} |
| 1139 |
|
| 1140 |
|
| 1141 |
/* terminal_print_arrow(): |
| 1142 |
* Print the arrow key bindings |
| 1143 |
*/ |
| 1144 |
libedit_private void |
| 1145 |
terminal_print_arrow(EditLine *el, const wchar_t *name) |
| 1146 |
{ |
| 1147 |
int i; |
| 1148 |
funckey_t *arrow = el->el_terminal.t_fkey; |
| 1149 |
|
| 1150 |
for (i = 0; i < A_K_NKEYS; i++) |
| 1151 |
if (*name == '\0' || wcscmp(name, arrow[i].name) == 0) |
| 1152 |
if (arrow[i].type != XK_NOD) |
| 1153 |
keymacro_kprint(el, arrow[i].name, |
| 1154 |
&arrow[i].fun, arrow[i].type); |
| 1155 |
} |
| 1156 |
|
| 1157 |
|
| 1158 |
/* terminal_bind_arrow(): |
| 1159 |
* Bind the arrow keys |
| 1160 |
*/ |
| 1161 |
libedit_private void |
| 1162 |
terminal_bind_arrow(EditLine *el) |
| 1163 |
{ |
| 1164 |
el_action_t *map; |
| 1165 |
const el_action_t *dmap; |
| 1166 |
int i, j; |
| 1167 |
char *p; |
| 1168 |
funckey_t *arrow = el->el_terminal.t_fkey; |
| 1169 |
|
| 1170 |
/* Check if the components needed are initialized */ |
| 1171 |
if (el->el_terminal.t_buf == NULL || el->el_map.key == NULL) |
| 1172 |
return; |
| 1173 |
|
| 1174 |
map = el->el_map.type == MAP_VI ? el->el_map.alt : el->el_map.key; |
| 1175 |
dmap = el->el_map.type == MAP_VI ? el->el_map.vic : el->el_map.emacs; |
| 1176 |
|
| 1177 |
terminal_reset_arrow(el); |
| 1178 |
|
| 1179 |
for (i = 0; i < A_K_NKEYS; i++) { |
| 1180 |
wchar_t wt_str[VISUAL_WIDTH_MAX]; |
| 1181 |
wchar_t *px; |
| 1182 |
size_t n; |
| 1183 |
|
| 1184 |
p = el->el_terminal.t_str[arrow[i].key]; |
| 1185 |
if (!p || !*p) |
| 1186 |
continue; |
| 1187 |
for (n = 0; n < VISUAL_WIDTH_MAX && p[n]; ++n) |
| 1188 |
wt_str[n] = p[n]; |
| 1189 |
while (n < VISUAL_WIDTH_MAX) |
| 1190 |
wt_str[n++] = '\0'; |
| 1191 |
px = wt_str; |
| 1192 |
j = (unsigned char) *p; |
| 1193 |
/* |
| 1194 |
* Assign the arrow keys only if: |
| 1195 |
* |
| 1196 |
* 1. They are multi-character arrow keys and the user |
| 1197 |
* has not re-assigned the leading character, or |
| 1198 |
* has re-assigned the leading character to be |
| 1199 |
* ED_SEQUENCE_LEAD_IN |
| 1200 |
* 2. They are single arrow keys pointing to an |
| 1201 |
* unassigned key. |
| 1202 |
*/ |
| 1203 |
if (arrow[i].type == XK_NOD) |
| 1204 |
keymacro_clear(el, map, px); |
| 1205 |
else { |
| 1206 |
if (p[1] && (dmap[j] == map[j] || |
| 1207 |
map[j] == ED_SEQUENCE_LEAD_IN)) { |
| 1208 |
keymacro_add(el, px, &arrow[i].fun, |
| 1209 |
arrow[i].type); |
| 1210 |
map[j] = ED_SEQUENCE_LEAD_IN; |
| 1211 |
} else if (map[j] == ED_UNASSIGNED) { |
| 1212 |
keymacro_clear(el, map, px); |
| 1213 |
if (arrow[i].type == XK_CMD) |
| 1214 |
map[j] = arrow[i].fun.cmd; |
| 1215 |
else |
| 1216 |
keymacro_add(el, px, &arrow[i].fun, |
| 1217 |
arrow[i].type); |
| 1218 |
} |
| 1219 |
} |
| 1220 |
} |
| 1221 |
} |
| 1222 |
|
| 1223 |
/* terminal_putc(): |
| 1224 |
* Add a character |
| 1225 |
*/ |
| 1226 |
static int |
| 1227 |
terminal_putc(int c) |
| 1228 |
{ |
| 1229 |
if (terminal_outfile == NULL) |
| 1230 |
return -1; |
| 1231 |
return fputc(c, terminal_outfile); |
| 1232 |
} |
| 1233 |
|
| 1234 |
static void |
| 1235 |
terminal_tputs(EditLine *el, const char *cap, int affcnt) |
| 1236 |
{ |
| 1237 |
#ifdef _REENTRANT |
| 1238 |
pthread_mutex_lock(&terminal_mutex); |
| 1239 |
#endif |
| 1240 |
terminal_outfile = el->el_outfile; |
| 1241 |
(void)tputs(cap, affcnt, terminal_putc); |
| 1242 |
#ifdef _REENTRANT |
| 1243 |
pthread_mutex_unlock(&terminal_mutex); |
| 1244 |
#endif |
| 1245 |
} |
| 1246 |
|
| 1247 |
/* terminal__putc(): |
| 1248 |
* Add a character |
| 1249 |
*/ |
| 1250 |
libedit_private int |
| 1251 |
terminal__putc(EditLine *el, wint_t c) |
| 1252 |
{ |
| 1253 |
char buf[MB_LEN_MAX +1]; |
| 1254 |
ssize_t i; |
| 1255 |
if (c == (wint_t)MB_FILL_CHAR) |
| 1256 |
return 0; |
| 1257 |
i = ct_encode_char(buf, (size_t)MB_LEN_MAX, c); |
| 1258 |
if (i <= 0) |
| 1259 |
return (int)i; |
| 1260 |
buf[i] = '\0'; |
| 1261 |
return fputs(buf, el->el_outfile); |
| 1262 |
} |
| 1263 |
|
| 1264 |
/* terminal__flush(): |
| 1265 |
* Flush output |
| 1266 |
*/ |
| 1267 |
libedit_private void |
| 1268 |
terminal__flush(EditLine *el) |
| 1269 |
{ |
| 1270 |
|
| 1271 |
(void) fflush(el->el_outfile); |
| 1272 |
} |
| 1273 |
|
| 1274 |
/* terminal_writec(): |
| 1275 |
* Write the given character out, in a human readable form |
| 1276 |
*/ |
| 1277 |
libedit_private void |
| 1278 |
terminal_writec(EditLine *el, wint_t c) |
| 1279 |
{ |
| 1280 |
wchar_t visbuf[VISUAL_WIDTH_MAX +1]; |
| 1281 |
ssize_t vcnt = ct_visual_char(visbuf, VISUAL_WIDTH_MAX, c); |
| 1282 |
if (vcnt < 0) |
| 1283 |
vcnt = 0; |
| 1284 |
visbuf[vcnt] = '\0'; |
| 1285 |
terminal_overwrite(el, visbuf, (size_t)vcnt); |
| 1286 |
terminal__flush(el); |
| 1287 |
} |
| 1288 |
|
| 1289 |
|
| 1290 |
/* terminal_telltc(): |
| 1291 |
* Print the current termcap characteristics |
| 1292 |
*/ |
| 1293 |
libedit_private int |
| 1294 |
/*ARGSUSED*/ |
| 1295 |
terminal_telltc(EditLine *el, int argc __attribute__((__unused__)), |
| 1296 |
const wchar_t **argv __attribute__((__unused__))) |
| 1297 |
{ |
| 1298 |
const struct termcapstr *t; |
| 1299 |
char **ts; |
| 1300 |
|
| 1301 |
(void) fprintf(el->el_outfile, "\n\tYour terminal has the\n"); |
| 1302 |
(void) fprintf(el->el_outfile, "\tfollowing characteristics:\n\n"); |
| 1303 |
(void) fprintf(el->el_outfile, "\tIt has %d columns and %d lines\n", |
| 1304 |
Val(T_co), Val(T_li)); |
| 1305 |
(void) fprintf(el->el_outfile, |
| 1306 |
"\tIt has %s meta key\n", EL_HAS_META ? "a" : "no"); |
| 1307 |
(void) fprintf(el->el_outfile, |
| 1308 |
"\tIt can%suse tabs\n", EL_CAN_TAB ? " " : "not "); |
| 1309 |
(void) fprintf(el->el_outfile, "\tIt %s automatic margins\n", |
| 1310 |
EL_HAS_AUTO_MARGINS ? "has" : "does not have"); |
| 1311 |
if (EL_HAS_AUTO_MARGINS) |
| 1312 |
(void) fprintf(el->el_outfile, "\tIt %s magic margins\n", |
| 1313 |
EL_HAS_MAGIC_MARGINS ? "has" : "does not have"); |
| 1314 |
|
| 1315 |
for (t = tstr, ts = el->el_terminal.t_str; t->name != NULL; t++, ts++) { |
| 1316 |
const char *ub; |
| 1317 |
if (*ts && **ts) { |
| 1318 |
ub = ct_encode_string(ct_visual_string( |
| 1319 |
ct_decode_string(*ts, &el->el_scratch), |
| 1320 |
&el->el_visual), &el->el_scratch); |
| 1321 |
} else { |
| 1322 |
ub = "(empty)"; |
| 1323 |
} |
| 1324 |
(void) fprintf(el->el_outfile, "\t%25s (%s) == %s\n", |
| 1325 |
t->long_name, t->name, ub); |
| 1326 |
} |
| 1327 |
(void) fputc('\n', el->el_outfile); |
| 1328 |
return 0; |
| 1329 |
} |
| 1330 |
|
| 1331 |
|
| 1332 |
/* terminal_settc(): |
| 1333 |
* Change the current terminal characteristics |
| 1334 |
*/ |
| 1335 |
libedit_private int |
| 1336 |
/*ARGSUSED*/ |
| 1337 |
terminal_settc(EditLine *el, int argc __attribute__((__unused__)), |
| 1338 |
const wchar_t **argv) |
| 1339 |
{ |
| 1340 |
const struct termcapstr *ts; |
| 1341 |
const struct termcapval *tv; |
| 1342 |
char what[8], how[8]; |
| 1343 |
|
| 1344 |
if (argv == NULL || argv[1] == NULL || argv[2] == NULL) |
| 1345 |
return -1; |
| 1346 |
|
| 1347 |
strncpy(what, ct_encode_string(argv[1], &el->el_scratch), sizeof(what)); |
| 1348 |
what[sizeof(what) - 1] = '\0'; |
| 1349 |
strncpy(how, ct_encode_string(argv[2], &el->el_scratch), sizeof(how)); |
| 1350 |
how[sizeof(how) - 1] = '\0'; |
| 1351 |
|
| 1352 |
/* |
| 1353 |
* Do the strings first |
| 1354 |
*/ |
| 1355 |
for (ts = tstr; ts->name != NULL; ts++) |
| 1356 |
if (strcmp(ts->name, what) == 0) |
| 1357 |
break; |
| 1358 |
|
| 1359 |
if (ts->name != NULL) { |
| 1360 |
terminal_alloc(el, ts, how); |
| 1361 |
terminal_setflags(el); |
| 1362 |
return 0; |
| 1363 |
} |
| 1364 |
/* |
| 1365 |
* Do the numeric ones second |
| 1366 |
*/ |
| 1367 |
for (tv = tval; tv->name != NULL; tv++) |
| 1368 |
if (strcmp(tv->name, what) == 0) |
| 1369 |
break; |
| 1370 |
|
| 1371 |
if (tv->name != NULL) |
| 1372 |
return -1; |
| 1373 |
|
| 1374 |
if (tv == &tval[T_pt] || tv == &tval[T_km] || |
| 1375 |
tv == &tval[T_am] || tv == &tval[T_xn]) { |
| 1376 |
if (strcmp(how, "yes") == 0) |
| 1377 |
el->el_terminal.t_val[tv - tval] = 1; |
| 1378 |
else if (strcmp(how, "no") == 0) |
| 1379 |
el->el_terminal.t_val[tv - tval] = 0; |
| 1380 |
else { |
| 1381 |
(void) fprintf(el->el_errfile, |
| 1382 |
"%ls: Bad value `%s'.\n", argv[0], how); |
| 1383 |
return -1; |
| 1384 |
} |
| 1385 |
terminal_setflags(el); |
| 1386 |
if (terminal_change_size(el, Val(T_li), Val(T_co)) == -1) |
| 1387 |
return -1; |
| 1388 |
return 0; |
| 1389 |
} else { |
| 1390 |
long i; |
| 1391 |
char *ep; |
| 1392 |
|
| 1393 |
i = strtol(how, &ep, 10); |
| 1394 |
if (*ep != '\0') { |
| 1395 |
(void) fprintf(el->el_errfile, |
| 1396 |
"%ls: Bad value `%s'.\n", argv[0], how); |
| 1397 |
return -1; |
| 1398 |
} |
| 1399 |
el->el_terminal.t_val[tv - tval] = (int) i; |
| 1400 |
el->el_terminal.t_size.v = Val(T_co); |
| 1401 |
el->el_terminal.t_size.h = Val(T_li); |
| 1402 |
if (tv == &tval[T_co] || tv == &tval[T_li]) |
| 1403 |
if (terminal_change_size(el, Val(T_li), Val(T_co)) |
| 1404 |
== -1) |
| 1405 |
return -1; |
| 1406 |
return 0; |
| 1407 |
} |
| 1408 |
} |
| 1409 |
|
| 1410 |
|
| 1411 |
/* terminal_gettc(): |
| 1412 |
* Get the current terminal characteristics |
| 1413 |
*/ |
| 1414 |
libedit_private int |
| 1415 |
/*ARGSUSED*/ |
| 1416 |
terminal_gettc(EditLine *el, int argc __attribute__((__unused__)), char **argv) |
| 1417 |
{ |
| 1418 |
const struct termcapstr *ts; |
| 1419 |
const struct termcapval *tv; |
| 1420 |
char *what; |
| 1421 |
void *how; |
| 1422 |
|
| 1423 |
if (argv == NULL || argv[1] == NULL || argv[2] == NULL) |
| 1424 |
return -1; |
| 1425 |
|
| 1426 |
what = argv[1]; |
| 1427 |
how = argv[2]; |
| 1428 |
|
| 1429 |
/* |
| 1430 |
* Do the strings first |
| 1431 |
*/ |
| 1432 |
for (ts = tstr; ts->name != NULL; ts++) |
| 1433 |
if (strcmp(ts->name, what) == 0) |
| 1434 |
break; |
| 1435 |
|
| 1436 |
if (ts->name != NULL) { |
| 1437 |
*(char **)how = el->el_terminal.t_str[ts - tstr]; |
| 1438 |
return 0; |
| 1439 |
} |
| 1440 |
/* |
| 1441 |
* Do the numeric ones second |
| 1442 |
*/ |
| 1443 |
for (tv = tval; tv->name != NULL; tv++) |
| 1444 |
if (strcmp(tv->name, what) == 0) |
| 1445 |
break; |
| 1446 |
|
| 1447 |
if (tv->name == NULL) |
| 1448 |
return -1; |
| 1449 |
|
| 1450 |
if (tv == &tval[T_pt] || tv == &tval[T_km] || |
| 1451 |
tv == &tval[T_am] || tv == &tval[T_xn]) { |
| 1452 |
static char yes[] = "yes"; |
| 1453 |
static char no[] = "no"; |
| 1454 |
if (el->el_terminal.t_val[tv - tval]) |
| 1455 |
*(char **)how = yes; |
| 1456 |
else |
| 1457 |
*(char **)how = no; |
| 1458 |
return 0; |
| 1459 |
} else { |
| 1460 |
*(int *)how = el->el_terminal.t_val[tv - tval]; |
| 1461 |
return 0; |
| 1462 |
} |
| 1463 |
} |
| 1464 |
|
| 1465 |
/* terminal_echotc(): |
| 1466 |
* Print the termcap string out with variable substitution |
| 1467 |
*/ |
| 1468 |
libedit_private int |
| 1469 |
/*ARGSUSED*/ |
| 1470 |
terminal_echotc(EditLine *el, int argc __attribute__((__unused__)), |
| 1471 |
const wchar_t **argv) |
| 1472 |
{ |
| 1473 |
char *cap, *scap; |
| 1474 |
wchar_t *ep; |
| 1475 |
int arg_need, arg_cols, arg_rows; |
| 1476 |
int verbose = 0, silent = 0; |
| 1477 |
char *area; |
| 1478 |
static const char fmts[] = "%s\n", fmtd[] = "%d\n"; |
| 1479 |
const struct termcapstr *t; |
| 1480 |
char buf[TC_BUFSIZE]; |
| 1481 |
long i; |
| 1482 |
|
| 1483 |
area = buf; |
| 1484 |
|
| 1485 |
if (argv == NULL || argv[1] == NULL) |
| 1486 |
return -1; |
| 1487 |
argv++; |
| 1488 |
|
| 1489 |
if (argv[0][0] == '-') { |
| 1490 |
switch (argv[0][1]) { |
| 1491 |
case 'v': |
| 1492 |
verbose = 1; |
| 1493 |
break; |
| 1494 |
case 's': |
| 1495 |
silent = 1; |
| 1496 |
break; |
| 1497 |
default: |
| 1498 |
/* stderror(ERR_NAME | ERR_TCUSAGE); */ |
| 1499 |
break; |
| 1500 |
} |
| 1501 |
argv++; |
| 1502 |
} |
| 1503 |
if (!*argv || *argv[0] == '\0') |
| 1504 |
return 0; |
| 1505 |
if (wcscmp(*argv, L"tabs") == 0) { |
| 1506 |
(void) fprintf(el->el_outfile, fmts, EL_CAN_TAB ? "yes" : "no"); |
| 1507 |
return 0; |
| 1508 |
} else if (wcscmp(*argv, L"meta") == 0) { |
| 1509 |
(void) fprintf(el->el_outfile, fmts, Val(T_km) ? "yes" : "no"); |
| 1510 |
return 0; |
| 1511 |
} else if (wcscmp(*argv, L"xn") == 0) { |
| 1512 |
(void) fprintf(el->el_outfile, fmts, EL_HAS_MAGIC_MARGINS ? |
| 1513 |
"yes" : "no"); |
| 1514 |
return 0; |
| 1515 |
} else if (wcscmp(*argv, L"am") == 0) { |
| 1516 |
(void) fprintf(el->el_outfile, fmts, EL_HAS_AUTO_MARGINS ? |
| 1517 |
"yes" : "no"); |
| 1518 |
return 0; |
| 1519 |
} else if (wcscmp(*argv, L"baud") == 0) { |
| 1520 |
(void) fprintf(el->el_outfile, fmtd, (int)el->el_tty.t_speed); |
| 1521 |
return 0; |
| 1522 |
} else if (wcscmp(*argv, L"rows") == 0 || |
| 1523 |
wcscmp(*argv, L"lines") == 0) { |
| 1524 |
(void) fprintf(el->el_outfile, fmtd, Val(T_li)); |
| 1525 |
return 0; |
| 1526 |
} else if (wcscmp(*argv, L"cols") == 0) { |
| 1527 |
(void) fprintf(el->el_outfile, fmtd, Val(T_co)); |
| 1528 |
return 0; |
| 1529 |
} |
| 1530 |
/* |
| 1531 |
* Try to use our local definition first |
| 1532 |
*/ |
| 1533 |
scap = NULL; |
| 1534 |
for (t = tstr; t->name != NULL; t++) |
| 1535 |
if (strcmp(t->name, |
| 1536 |
ct_encode_string(*argv, &el->el_scratch)) == 0) { |
| 1537 |
scap = el->el_terminal.t_str[t - tstr]; |
| 1538 |
break; |
| 1539 |
} |
| 1540 |
if (t->name == NULL) { |
| 1541 |
/* XXX: some systems' tgetstr needs non const */ |
| 1542 |
scap = tgetstr(ct_encode_string(*argv, &el->el_scratch), &area); |
| 1543 |
} |
| 1544 |
if (!scap || scap[0] == '\0') { |
| 1545 |
if (!silent) |
| 1546 |
(void) fprintf(el->el_errfile, |
| 1547 |
"echotc: Termcap parameter `%ls' not found.\n", |
| 1548 |
*argv); |
| 1549 |
return -1; |
| 1550 |
} |
| 1551 |
/* |
| 1552 |
* Count home many values we need for this capability. |
| 1553 |
*/ |
| 1554 |
for (cap = scap, arg_need = 0; *cap; cap++) |
| 1555 |
if (*cap == '%') |
| 1556 |
switch (*++cap) { |
| 1557 |
case 'd': |
| 1558 |
case '2': |
| 1559 |
case '3': |
| 1560 |
case '.': |
| 1561 |
case '+': |
| 1562 |
arg_need++; |
| 1563 |
break; |
| 1564 |
case '%': |
| 1565 |
case '>': |
| 1566 |
case 'i': |
| 1567 |
case 'r': |
| 1568 |
case 'n': |
| 1569 |
case 'B': |
| 1570 |
case 'D': |
| 1571 |
break; |
| 1572 |
default: |
| 1573 |
/* |
| 1574 |
* hpux has lot's of them... |
| 1575 |
*/ |
| 1576 |
if (verbose) |
| 1577 |
(void) fprintf(el->el_errfile, |
| 1578 |
"echotc: Warning: unknown termcap %% `%c'.\n", |
| 1579 |
*cap); |
| 1580 |
/* This is bad, but I won't complain */ |
| 1581 |
break; |
| 1582 |
} |
| 1583 |
|
| 1584 |
switch (arg_need) { |
| 1585 |
case 0: |
| 1586 |
argv++; |
| 1587 |
if (*argv && *argv[0]) { |
| 1588 |
if (!silent) |
| 1589 |
(void) fprintf(el->el_errfile, |
| 1590 |
"echotc: Warning: Extra argument `%ls'.\n", |
| 1591 |
*argv); |
| 1592 |
return -1; |
| 1593 |
} |
| 1594 |
terminal_tputs(el, scap, 1); |
| 1595 |
break; |
| 1596 |
case 1: |
| 1597 |
argv++; |
| 1598 |
if (!*argv || *argv[0] == '\0') { |
| 1599 |
if (!silent) |
| 1600 |
(void) fprintf(el->el_errfile, |
| 1601 |
"echotc: Warning: Missing argument.\n"); |
| 1602 |
return -1; |
| 1603 |
} |
| 1604 |
arg_cols = 0; |
| 1605 |
i = wcstol(*argv, &ep, 10); |
| 1606 |
if (*ep != '\0' || i < 0) { |
| 1607 |
if (!silent) |
| 1608 |
(void) fprintf(el->el_errfile, |
| 1609 |
"echotc: Bad value `%ls' for rows.\n", |
| 1610 |
*argv); |
| 1611 |
return -1; |
| 1612 |
} |
| 1613 |
arg_rows = (int) i; |
| 1614 |
argv++; |
| 1615 |
if (*argv && *argv[0]) { |
| 1616 |
if (!silent) |
| 1617 |
(void) fprintf(el->el_errfile, |
| 1618 |
"echotc: Warning: Extra argument `%ls" |
| 1619 |
"'.\n", *argv); |
| 1620 |
return -1; |
| 1621 |
} |
| 1622 |
terminal_tputs(el, tgoto(scap, arg_cols, arg_rows), 1); |
| 1623 |
break; |
| 1624 |
default: |
| 1625 |
/* This is wrong, but I will ignore it... */ |
| 1626 |
if (verbose) |
| 1627 |
(void) fprintf(el->el_errfile, |
| 1628 |
"echotc: Warning: Too many required arguments (%d).\n", |
| 1629 |
arg_need); |
| 1630 |
/* FALLTHROUGH */ |
| 1631 |
case 2: |
| 1632 |
argv++; |
| 1633 |
if (!*argv || *argv[0] == '\0') { |
| 1634 |
if (!silent) |
| 1635 |
(void) fprintf(el->el_errfile, |
| 1636 |
"echotc: Warning: Missing argument.\n"); |
| 1637 |
return -1; |
| 1638 |
} |
| 1639 |
i = wcstol(*argv, &ep, 10); |
| 1640 |
if (*ep != '\0' || i < 0) { |
| 1641 |
if (!silent) |
| 1642 |
(void) fprintf(el->el_errfile, |
| 1643 |
"echotc: Bad value `%ls' for cols.\n", |
| 1644 |
*argv); |
| 1645 |
return -1; |
| 1646 |
} |
| 1647 |
arg_cols = (int) i; |
| 1648 |
argv++; |
| 1649 |
if (!*argv || *argv[0] == '\0') { |
| 1650 |
if (!silent) |
| 1651 |
(void) fprintf(el->el_errfile, |
| 1652 |
"echotc: Warning: Missing argument.\n"); |
| 1653 |
return -1; |
| 1654 |
} |
| 1655 |
i = wcstol(*argv, &ep, 10); |
| 1656 |
if (*ep != '\0' || i < 0) { |
| 1657 |
if (!silent) |
| 1658 |
(void) fprintf(el->el_errfile, |
| 1659 |
"echotc: Bad value `%ls' for rows.\n", |
| 1660 |
*argv); |
| 1661 |
return -1; |
| 1662 |
} |
| 1663 |
arg_rows = (int) i; |
| 1664 |
if (*ep != '\0') { |
| 1665 |
if (!silent) |
| 1666 |
(void) fprintf(el->el_errfile, |
| 1667 |
"echotc: Bad value `%ls'.\n", *argv); |
| 1668 |
return -1; |
| 1669 |
} |
| 1670 |
argv++; |
| 1671 |
if (*argv && *argv[0]) { |
| 1672 |
if (!silent) |
| 1673 |
(void) fprintf(el->el_errfile, |
| 1674 |
"echotc: Warning: Extra argument `%ls" |
| 1675 |
"'.\n", *argv); |
| 1676 |
return -1; |
| 1677 |
} |
| 1678 |
terminal_tputs(el, tgoto(scap, arg_cols, arg_rows), arg_rows); |
| 1679 |
break; |
| 1680 |
} |
| 1681 |
return 0; |
| 1682 |
} |