getch.c revision 1.76
1 /* $NetBSD: getch.c,v 1.76 2021/09/06 07:03:49 rin Exp $ */ 2 3 /* 4 * Copyright (c) 1981, 1993, 1994 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 #ifndef lint 34 #if 0 35 static char sccsid[] = "@(#)getch.c 8.2 (Berkeley) 5/4/94"; 36 #else 37 __RCSID("$NetBSD: getch.c,v 1.76 2021/09/06 07:03:49 rin Exp $"); 38 #endif 39 #endif /* not lint */ 40 41 #include <errno.h> 42 #include <string.h> 43 #include <stdlib.h> 44 #include <unistd.h> 45 #include <stdio.h> 46 #include "curses.h" 47 #include "curses_private.h" 48 #include "keymap.h" 49 50 short _cursesi_state; /* state of the inkey function */ 51 52 static const struct tcdata tc[] = { 53 {TICODE_kSAV, KEY_SSAVE}, 54 {TICODE_kSPD, KEY_SSUSPEND}, 55 {TICODE_kUND, KEY_SUNDO}, 56 {TICODE_kHLP, KEY_SHELP}, 57 {TICODE_kHOM, KEY_SHOME}, 58 {TICODE_kIC, KEY_SIC}, 59 {TICODE_kLFT, KEY_SLEFT}, 60 {TICODE_krdo, KEY_REDO}, 61 {TICODE_khlp, KEY_HELP}, 62 {TICODE_kmrk, KEY_MARK}, 63 {TICODE_kmsg, KEY_MESSAGE}, 64 {TICODE_kmov, KEY_MOVE}, 65 {TICODE_knxt, KEY_NEXT}, 66 {TICODE_kopn, KEY_OPEN}, 67 {TICODE_kopt, KEY_OPTIONS}, 68 {TICODE_kprv, KEY_PREVIOUS}, 69 {TICODE_kprt, KEY_PRINT}, 70 {TICODE_kMSG, KEY_SMESSAGE}, 71 {TICODE_kMOV, KEY_SMOVE}, 72 {TICODE_kNXT, KEY_SNEXT}, 73 {TICODE_kOPT, KEY_SOPTIONS}, 74 {TICODE_kPRV, KEY_SPREVIOUS}, 75 {TICODE_kPRT, KEY_SPRINT}, 76 {TICODE_kRDO, KEY_SREDO}, 77 {TICODE_kRPL, KEY_SREPLACE}, 78 {TICODE_kRIT, KEY_SRIGHT}, 79 {TICODE_kRES, KEY_SRSUME}, 80 {TICODE_kCAN, KEY_SCANCEL}, 81 {TICODE_kref, KEY_REFERENCE}, 82 {TICODE_krfr, KEY_REFRESH}, 83 {TICODE_krpl, KEY_REPLACE}, 84 {TICODE_krst, KEY_RESTART}, 85 {TICODE_kres, KEY_RESUME}, 86 {TICODE_ksav, KEY_SAVE}, 87 {TICODE_kspd, KEY_SUSPEND}, 88 {TICODE_kund, KEY_UNDO}, 89 {TICODE_kBEG, KEY_SBEG}, 90 {TICODE_kFND, KEY_SFIND}, 91 {TICODE_kCMD, KEY_SCOMMAND}, 92 {TICODE_kCPY, KEY_SCOPY}, 93 {TICODE_kCRT, KEY_SCREATE}, 94 {TICODE_kDC, KEY_SDC}, 95 {TICODE_kDL, KEY_SDL}, 96 {TICODE_kslt, KEY_SELECT}, 97 {TICODE_kEND, KEY_SEND}, 98 {TICODE_kEOL, KEY_SEOL}, 99 {TICODE_kEXT, KEY_SEXIT}, 100 {TICODE_kfnd, KEY_FIND}, 101 {TICODE_kbeg, KEY_BEG}, 102 {TICODE_kcan, KEY_CANCEL}, 103 {TICODE_kclo, KEY_CLOSE}, 104 {TICODE_kcmd, KEY_COMMAND}, 105 {TICODE_kcpy, KEY_COPY}, 106 {TICODE_kcrt, KEY_CREATE}, 107 {TICODE_kend, KEY_END}, 108 {TICODE_kent, KEY_ENTER}, 109 {TICODE_kext, KEY_EXIT}, 110 {TICODE_kf11, KEY_F(11)}, 111 {TICODE_kf12, KEY_F(12)}, 112 {TICODE_kf13, KEY_F(13)}, 113 {TICODE_kf14, KEY_F(14)}, 114 {TICODE_kf15, KEY_F(15)}, 115 {TICODE_kf16, KEY_F(16)}, 116 {TICODE_kf17, KEY_F(17)}, 117 {TICODE_kf18, KEY_F(18)}, 118 {TICODE_kf19, KEY_F(19)}, 119 {TICODE_kf20, KEY_F(20)}, 120 {TICODE_kf21, KEY_F(21)}, 121 {TICODE_kf22, KEY_F(22)}, 122 {TICODE_kf23, KEY_F(23)}, 123 {TICODE_kf24, KEY_F(24)}, 124 {TICODE_kf25, KEY_F(25)}, 125 {TICODE_kf26, KEY_F(26)}, 126 {TICODE_kf27, KEY_F(27)}, 127 {TICODE_kf28, KEY_F(28)}, 128 {TICODE_kf29, KEY_F(29)}, 129 {TICODE_kf30, KEY_F(30)}, 130 {TICODE_kf31, KEY_F(31)}, 131 {TICODE_kf32, KEY_F(32)}, 132 {TICODE_kf33, KEY_F(33)}, 133 {TICODE_kf34, KEY_F(34)}, 134 {TICODE_kf35, KEY_F(35)}, 135 {TICODE_kf36, KEY_F(36)}, 136 {TICODE_kf37, KEY_F(37)}, 137 {TICODE_kf38, KEY_F(38)}, 138 {TICODE_kf39, KEY_F(39)}, 139 {TICODE_kf40, KEY_F(40)}, 140 {TICODE_kf41, KEY_F(41)}, 141 {TICODE_kf42, KEY_F(42)}, 142 {TICODE_kf43, KEY_F(43)}, 143 {TICODE_kf44, KEY_F(44)}, 144 {TICODE_kf45, KEY_F(45)}, 145 {TICODE_kf46, KEY_F(46)}, 146 {TICODE_kf47, KEY_F(47)}, 147 {TICODE_kf48, KEY_F(48)}, 148 {TICODE_kf49, KEY_F(49)}, 149 {TICODE_kf50, KEY_F(50)}, 150 {TICODE_kf51, KEY_F(51)}, 151 {TICODE_kf52, KEY_F(52)}, 152 {TICODE_kf53, KEY_F(53)}, 153 {TICODE_kf54, KEY_F(54)}, 154 {TICODE_kf55, KEY_F(55)}, 155 {TICODE_kf56, KEY_F(56)}, 156 {TICODE_kf57, KEY_F(57)}, 157 {TICODE_kf58, KEY_F(58)}, 158 {TICODE_kf59, KEY_F(59)}, 159 {TICODE_kf60, KEY_F(60)}, 160 {TICODE_kf61, KEY_F(61)}, 161 {TICODE_kf62, KEY_F(62)}, 162 {TICODE_kf63, KEY_F(63)}, 163 {TICODE_ka1, KEY_A1}, 164 {TICODE_kb2, KEY_B2}, 165 {TICODE_ka3, KEY_A3}, 166 {TICODE_kc1, KEY_C1}, 167 {TICODE_kc3, KEY_C3}, 168 {TICODE_kmous, KEY_MOUSE}, 169 {TICODE_kf0, KEY_F0}, 170 {TICODE_kf1, KEY_F(1)}, 171 {TICODE_kf2, KEY_F(2)}, 172 {TICODE_kf3, KEY_F(3)}, 173 {TICODE_kf4, KEY_F(4)}, 174 {TICODE_kf5, KEY_F(5)}, 175 {TICODE_kf6, KEY_F(6)}, 176 {TICODE_kf7, KEY_F(7)}, 177 {TICODE_kf8, KEY_F(8)}, 178 {TICODE_kf9, KEY_F(9)}, 179 {TICODE_kf10, KEY_F(10)}, 180 {TICODE_kil1, KEY_IL}, 181 {TICODE_ktbc, KEY_CATAB}, 182 {TICODE_kcbt, KEY_BTAB}, 183 {TICODE_kbs, KEY_BACKSPACE}, 184 {TICODE_kclr, KEY_CLEAR}, 185 {TICODE_kdch1, KEY_DC}, 186 {TICODE_kcud1, KEY_DOWN}, 187 {TICODE_kel, KEY_EOL}, 188 {TICODE_kind, KEY_SF}, 189 {TICODE_kll, KEY_LL}, 190 {TICODE_khome, KEY_HOME}, 191 {TICODE_kich1, KEY_IC}, 192 {TICODE_kdl1, KEY_DL}, 193 {TICODE_kcub1, KEY_LEFT}, 194 {TICODE_krmir, KEY_EIC}, 195 {TICODE_knp, KEY_NPAGE}, 196 {TICODE_kpp, KEY_PPAGE}, 197 {TICODE_kri, KEY_SR}, 198 {TICODE_kcuf1, KEY_RIGHT}, 199 {TICODE_ked, KEY_EOS}, 200 {TICODE_khts, KEY_STAB}, 201 {TICODE_kctab, KEY_CTAB}, 202 {TICODE_kcuu1, KEY_UP} 203 }; 204 /* Number of TC entries .... */ 205 static const int num_tcs = (sizeof(tc) / sizeof(struct tcdata)); 206 207 /* Key buffer */ 208 #define INBUF_SZ 16 /* size of key buffer - must be larger than 209 * longest multi-key sequence */ 210 static wchar_t inbuf[INBUF_SZ]; 211 static int start, end, working; /* pointers for manipulating inbuf data */ 212 213 /* prototypes for private functions */ 214 static void add_key_sequence(SCREEN *screen, char *sequence, int key_type); 215 static key_entry_t *add_new_key(keymap_t *current, char ch, int key_type, 216 int symbol); 217 static void delete_key_sequence(keymap_t *current, int key_type); 218 static void do_keyok(keymap_t *current, int key_type, bool set, bool flag, 219 int *retval); 220 static keymap_t *new_keymap(void); /* create a new keymap */ 221 static key_entry_t *new_key(void); /* create a new key entry */ 222 static wchar_t inkey(int to, int delay); 223 224 /* 225 * Free the storage associated with the given keymap 226 */ 227 void 228 _cursesi_free_keymap(keymap_t *map) 229 { 230 int i; 231 232 /* check for, and free, child keymaps */ 233 for (i = 0; i < MAX_CHAR; i++) { 234 if (map->mapping[i] >= 0) { 235 if (map->key[map->mapping[i]]->type == KEYMAP_MULTI) 236 _cursesi_free_keymap( 237 map->key[map->mapping[i]]->value.next); 238 } 239 } 240 241 /* now free any allocated keymap structs */ 242 for (i = 0; i < map->count; i += KEYMAP_ALLOC_CHUNK) { 243 free(map->key[i]); 244 } 245 246 free(map->key); 247 free(map); 248 } 249 250 251 /* 252 * Add a new key entry to the keymap pointed to by current. Entry 253 * contains the character to add to the keymap, type is the type of 254 * entry to add (either multikey or leaf) and symbol is the symbolic 255 * value for a leaf type entry. The function returns a pointer to the 256 * new keymap entry. 257 */ 258 static key_entry_t * 259 add_new_key(keymap_t *current, char chr, int key_type, int symbol) 260 { 261 key_entry_t *the_key; 262 int i, ki; 263 264 __CTRACE(__CTRACE_MISC, 265 "Adding character %s of type %d, symbol 0x%x\n", 266 unctrl(chr), key_type, symbol); 267 if (current->mapping[(unsigned char)chr] < 0) { 268 if (current->mapping[(unsigned char)chr] == MAPPING_UNUSED) { 269 /* first time for this char */ 270 current->mapping[(unsigned char)chr] = 271 current->count; /* map new entry */ 272 ki = current->count; 273 274 /* make sure we have room in the key array first */ 275 if ((current->count & (KEYMAP_ALLOC_CHUNK - 1)) == 0) 276 { 277 if ((current->key = 278 realloc(current->key, 279 ki * sizeof(key_entry_t *) 280 + KEYMAP_ALLOC_CHUNK * sizeof(key_entry_t *))) == NULL) { 281 fprintf(stderr, 282 "Could not malloc for key entry\n"); 283 exit(1); 284 } 285 286 the_key = new_key(); 287 for (i = 0; i < KEYMAP_ALLOC_CHUNK; i++) { 288 current->key[ki + i] = &the_key[i]; 289 } 290 } 291 } else { 292 /* the mapping was used but freed, reuse it */ 293 ki = - current->mapping[(unsigned char) chr]; 294 current->mapping[(unsigned char) chr] = ki; 295 } 296 297 current->count++; 298 299 /* point at the current key array element to use */ 300 the_key = current->key[ki]; 301 302 the_key->type = key_type; 303 304 switch (key_type) { 305 case KEYMAP_MULTI: 306 /* need for next key */ 307 __CTRACE(__CTRACE_MISC, "Creating new keymap\n"); 308 the_key->value.next = new_keymap(); 309 the_key->enable = TRUE; 310 break; 311 312 case KEYMAP_LEAF: 313 /* the associated symbol for the key */ 314 __CTRACE(__CTRACE_MISC, "Adding leaf key\n"); 315 the_key->value.symbol = symbol; 316 the_key->enable = TRUE; 317 break; 318 319 default: 320 fprintf(stderr, "add_new_key: bad type passed\n"); 321 exit(1); 322 } 323 } else { 324 /* the key is already known - just return the address. */ 325 __CTRACE(__CTRACE_MISC, "Keymap already known\n"); 326 the_key = current->key[current->mapping[(unsigned char)chr]]; 327 } 328 329 return the_key; 330 } 331 332 /* 333 * Delete the given key symbol from the key mappings for the screen. 334 * 335 */ 336 static void 337 delete_key_sequence(keymap_t *current, int key_type) 338 { 339 key_entry_t *key; 340 int i; 341 342 /* 343 * we need to iterate over all the keys as there may be 344 * multiple instances of the leaf symbol. 345 */ 346 for (i = 0; i < MAX_CHAR; i++) { 347 if (current->mapping[i] < 0) 348 continue; /* no mapping for the key, next! */ 349 350 key = current->key[current->mapping[i]]; 351 352 if (key->type == KEYMAP_MULTI) { 353 /* have not found the leaf, recurse down */ 354 delete_key_sequence(key->value.next, key_type); 355 /* if we deleted the last key in the map, free */ 356 if (key->value.next->count == 0) 357 _cursesi_free_keymap(key->value.next); 358 } else if ((key->type == KEYMAP_LEAF) 359 && (key->value.symbol == key_type)) { 360 __CTRACE(__CTRACE_INPUT, "delete_key_sequence: found keysym %d, deleting\n", 361 key_type); 362 key->enable = FALSE; 363 } 364 } 365 } 366 367 /* 368 * Add the sequence of characters given in sequence as the key mapping 369 * for the given key symbol. 370 */ 371 static void 372 add_key_sequence(SCREEN *screen, char *sequence, int key_type) 373 { 374 key_entry_t *tmp_key; 375 keymap_t *current; 376 int length, j, key_ent; 377 378 __CTRACE(__CTRACE_MISC, "add_key_sequence: add key sequence: %s(%s)\n", 379 sequence, keyname(key_type)); 380 current = screen->base_keymap; /* always start with 381 * base keymap. */ 382 length = (int)strlen(sequence); 383 384 /* 385 * OK - we really should never get a zero length string here, either 386 * the terminfo entry is there and it has a value or we are not called 387 * at all. Unfortunately, if someone assigns a terminfo string to the 388 * ^@ value we get passed a null string which messes up our length. 389 * So, if we get a null string then just insert a leaf value in 390 * the 0th char position of the root keymap. Note that we are 391 * totally screwed if someone terminates a multichar sequence 392 * with ^@... oh well. 393 */ 394 if (length == 0) 395 length = 1; 396 397 for (j = 0; j < length - 1; j++) { 398 /* add the entry to the struct */ 399 tmp_key = add_new_key(current, sequence[j], KEYMAP_MULTI, 0); 400 401 /* index into the key array - it's 402 clearer if we stash this */ 403 key_ent = current->mapping[(unsigned char) sequence[j]]; 404 405 current->key[key_ent] = tmp_key; 406 407 /* next key uses this map... */ 408 current = current->key[key_ent]->value.next; 409 } 410 411 /* 412 * This is the last key in the sequence (it may have been the 413 * only one but that does not matter) this means it is a leaf 414 * key and should have a symbol associated with it. 415 */ 416 tmp_key = add_new_key(current, sequence[length - 1], KEYMAP_LEAF, 417 key_type); 418 current->key[current->mapping[(int)sequence[length - 1]]] = tmp_key; 419 } 420 421 /* 422 * Init_getch - initialise all the pointers & structures needed to make 423 * getch work in keypad mode. 424 * 425 */ 426 void 427 __init_getch(SCREEN *screen) 428 { 429 char entry[1024], *p; 430 const char *s; 431 int i; 432 size_t limit, l; 433 #ifdef DEBUG 434 int k, length; 435 #endif 436 437 /* init the inkey state variable */ 438 _cursesi_state = INKEY_NORM; 439 440 /* init the base keymap */ 441 screen->base_keymap = new_keymap(); 442 443 /* key input buffer pointers */ 444 start = end = working = 0; 445 446 /* now do the terminfo snarfing ... */ 447 448 for (i = 0; i < num_tcs; i++) { 449 p = entry; 450 limit = 1023; 451 s = screen->term->strs[tc[i].code]; 452 if (s == NULL) 453 continue; 454 l = strlen(s) + 1; 455 if (limit < l) 456 continue; 457 strlcpy(p, s, limit); 458 p += l; 459 limit -= l; 460 #ifdef DEBUG 461 __CTRACE(__CTRACE_INIT, 462 "Processing terminfo entry %d, sequence ", 463 tc[i].code); 464 length = (int) strlen(entry); 465 for (k = 0; k <= length -1; k++) 466 __CTRACE(__CTRACE_INIT, "%s", unctrl(entry[k])); 467 __CTRACE(__CTRACE_INIT, "\n"); 468 #endif 469 add_key_sequence(screen, entry, tc[i].symbol); 470 } 471 } 472 473 474 /* 475 * new_keymap - allocates & initialises a new keymap structure. This 476 * function returns a pointer to the new keymap. 477 * 478 */ 479 static keymap_t * 480 new_keymap(void) 481 { 482 int i; 483 keymap_t *new_map; 484 485 if ((new_map = malloc(sizeof(keymap_t))) == NULL) { 486 perror("Inkey: Cannot allocate new keymap"); 487 exit(2); 488 } 489 490 /* Initialise the new map */ 491 new_map->count = 0; 492 for (i = 0; i < MAX_CHAR; i++) { 493 new_map->mapping[i] = MAPPING_UNUSED; /* no mapping for char */ 494 } 495 496 /* key array will be allocated when first key is added */ 497 new_map->key = NULL; 498 499 return new_map; 500 } 501 502 /* 503 * new_key - allocates & initialises a new key entry. This function returns 504 * a pointer to the newly allocated key entry. 505 * 506 */ 507 static key_entry_t * 508 new_key(void) 509 { 510 key_entry_t *new_one; 511 int i; 512 513 new_one = malloc(KEYMAP_ALLOC_CHUNK * sizeof(key_entry_t)); 514 if (new_one == NULL) { 515 perror("inkey: Cannot allocate new key entry chunk"); 516 exit(2); 517 } 518 519 for (i = 0; i < KEYMAP_ALLOC_CHUNK; i++) { 520 new_one[i].type = 0; 521 new_one[i].value.next = NULL; 522 } 523 524 return new_one; 525 } 526 527 /* 528 * inkey - do the work to process keyboard input, check for multi-key 529 * sequences and return the appropriate symbol if we get a match. 530 * 531 */ 532 533 static wchar_t 534 inkey(int to, int delay) 535 { 536 wchar_t k; 537 int c, mapping; 538 keymap_t *current = _cursesi_screen->base_keymap; 539 FILE *infd = _cursesi_screen->infd; 540 541 k = 0; /* XXX gcc -Wuninitialized */ 542 543 __CTRACE(__CTRACE_INPUT, "inkey (%d, %d)\n", to, delay); 544 for (;;) { /* loop until we get a complete key sequence */ 545 reread: 546 if (_cursesi_state == INKEY_NORM) { 547 if (delay && __timeout(delay) == ERR) 548 return ERR; 549 c = __fgetc_resize(infd); 550 if (c == ERR || c == KEY_RESIZE) { 551 clearerr(infd); 552 return c; 553 } 554 555 if (delay && (__notimeout() == ERR)) 556 return ERR; 557 558 k = (wchar_t)c; 559 __CTRACE(__CTRACE_INPUT, 560 "inkey (state normal) got '%s'\n", unctrl(k)); 561 562 working = start; 563 inbuf[working] = k; 564 INC_POINTER(working); 565 end = working; 566 567 /* go to the assembling state now */ 568 _cursesi_state = INKEY_ASSEMBLING; 569 570 } else if (_cursesi_state == INKEY_BACKOUT) { 571 k = inbuf[working]; 572 INC_POINTER(working); 573 if (working == end) { /* see if we have run 574 * out of keys in the 575 * backlog */ 576 577 /* if we have then switch to assembling */ 578 _cursesi_state = INKEY_ASSEMBLING; 579 } 580 } else if (_cursesi_state == INKEY_ASSEMBLING) { 581 /* assembling a key sequence */ 582 if (delay) { 583 if (__timeout(to ? (ESCDELAY / 100) : delay) 584 == ERR) 585 return ERR; 586 } else { 587 if (to && (__timeout(ESCDELAY / 100) == ERR)) 588 return ERR; 589 } 590 591 c = __fgetc_resize(infd); 592 if (ferror(infd)) { 593 clearerr(infd); 594 return c; 595 } 596 597 if ((to || delay) && (__notimeout() == ERR)) 598 return ERR; 599 600 __CTRACE(__CTRACE_INPUT, 601 "inkey (state assembling) got '%s'\n", unctrl(k)); 602 if (feof(infd) || c == -1) { /* inter-char timeout, 603 * start backing out */ 604 clearerr(infd); 605 if (start == end) 606 /* no chars in the buffer, restart */ 607 goto reread; 608 609 k = inbuf[start]; 610 _cursesi_state = INKEY_TIMEOUT; 611 } else { 612 k = (wchar_t) c; 613 inbuf[working] = k; 614 INC_POINTER(working); 615 end = working; 616 } 617 } else { 618 fprintf(stderr, "Inkey state screwed - exiting!!!"); 619 exit(2); 620 } 621 622 /* 623 * Check key has no special meaning and we have not 624 * timed out and the key has not been disabled 625 */ 626 mapping = current->mapping[k]; 627 if (((_cursesi_state == INKEY_TIMEOUT) || (mapping < 0)) 628 || ((current->key[mapping]->type == KEYMAP_LEAF) 629 && (current->key[mapping]->enable == FALSE))) { 630 /* return the first key we know about */ 631 k = inbuf[start]; 632 633 INC_POINTER(start); 634 working = start; 635 636 if (start == end) { /* only one char processed */ 637 _cursesi_state = INKEY_NORM; 638 } else {/* otherwise we must have more than one char 639 * to backout */ 640 _cursesi_state = INKEY_BACKOUT; 641 } 642 return k; 643 } else { /* must be part of a multikey sequence */ 644 /* check for completed key sequence */ 645 if (current->key[current->mapping[k]]->type == KEYMAP_LEAF) { 646 start = working; /* eat the key sequence 647 * in inbuf */ 648 649 /* check if inbuf empty now */ 650 if (start == end) { 651 /* if it is go back to normal */ 652 _cursesi_state = INKEY_NORM; 653 } else { 654 /* otherwise go to backout state */ 655 _cursesi_state = INKEY_BACKOUT; 656 } 657 658 /* return the symbol */ 659 return current->key[current->mapping[k]]->value.symbol; 660 661 } else { 662 /* 663 * Step on to next part of the multi-key 664 * sequence. 665 */ 666 current = current->key[current->mapping[k]]->value.next; 667 } 668 } 669 } 670 } 671 672 #ifndef _CURSES_USE_MACROS 673 /* 674 * getch -- 675 * Read in a character from stdscr. 676 */ 677 int 678 getch(void) 679 { 680 return wgetch(stdscr); 681 } 682 683 /* 684 * mvgetch -- 685 * Read in a character from stdscr at the given location. 686 */ 687 int 688 mvgetch(int y, int x) 689 { 690 return mvwgetch(stdscr, y, x); 691 } 692 693 /* 694 * mvwgetch -- 695 * Read in a character from stdscr at the given location in the 696 * given window. 697 */ 698 int 699 mvwgetch(WINDOW *win, int y, int x) 700 { 701 if (wmove(win, y, x) == ERR) 702 return ERR; 703 704 return wgetch(win); 705 } 706 707 #endif 708 709 /* 710 * keyok -- 711 * Set the enable flag for a keysym, if the flag is false then 712 * getch will not return this keysym even if the matching key sequence 713 * is seen. 714 */ 715 int 716 keyok(int key_type, bool flag) 717 { 718 int result = ERR; 719 720 if (_cursesi_screen != NULL) 721 do_keyok(_cursesi_screen->base_keymap, key_type, 722 true, flag, &result); 723 return result; 724 } 725 726 /* 727 * do_keyok -- 728 * Does the actual work for keyok, we need to recurse through the 729 * keymaps finding the passed key symbol. 730 */ 731 static void 732 do_keyok(keymap_t *current, int key_type, bool set, bool flag, int *retval) 733 { 734 key_entry_t *key; 735 int i; 736 737 /* 738 * we need to iterate over all the keys as there may be 739 * multiple instances of the leaf symbol. 740 */ 741 for (i = 0; i < MAX_CHAR; i++) { 742 if (current->mapping[i] < 0) 743 continue; /* no mapping for the key, next! */ 744 745 key = current->key[current->mapping[i]]; 746 747 if (key->type == KEYMAP_MULTI) 748 do_keyok(key->value.next, key_type, set, flag, retval); 749 else if ((key->type == KEYMAP_LEAF) 750 && (key->value.symbol == key_type)) { 751 if (set) 752 key->enable = flag; 753 *retval = OK; /* we found at least one instance, ok */ 754 } 755 } 756 } 757 758 /* 759 * define_key -- 760 * Add a custom mapping of a key sequence to key symbol. 761 * 762 */ 763 int 764 define_key(char *sequence, int symbol) 765 { 766 767 if (symbol <= 0 || _cursesi_screen == NULL) 768 return ERR; 769 770 if (sequence == NULL) { 771 __CTRACE(__CTRACE_INPUT, "define_key: deleting keysym %d\n", 772 symbol); 773 delete_key_sequence(_cursesi_screen->base_keymap, symbol); 774 } else 775 add_key_sequence(_cursesi_screen, sequence, symbol); 776 777 return OK; 778 } 779 780 /* 781 * wgetch -- 782 * Read in a character from the window. 783 */ 784 int 785 wgetch(WINDOW *win) 786 { 787 int inp, weset; 788 int c; 789 FILE *infd = _cursesi_screen->infd; 790 791 __CTRACE(__CTRACE_INPUT, "wgetch: win(%p)\n", win); 792 if (win == NULL) 793 return ERR; 794 if (!(win->flags & __SCROLLOK) && (win->flags & __FULLWIN) 795 && win->curx == win->maxx - 1 && win->cury == win->maxy - 1 796 && __echoit) 797 return ERR; 798 799 if (!(win->flags & __ISPAD)) { 800 if (is_wintouched(win)) 801 wrefresh(win); 802 else if ((_cursesi_screen->curscr->cury != (win->begy + win->cury)) 803 || (_cursesi_screen->curscr->curx != (win->begx + win->curx))) { 804 __CTRACE(__CTRACE_INPUT, "wgetch: curscr cury %d cury %d curscr curx %d curx %d\n", 805 _cursesi_screen->curscr->cury, win->begy + win->cury, 806 _cursesi_screen->curscr->curx, win->begx + win->curx); 807 /* 808 * Just in case the window is not dirty but the 809 * cursor was moved, check and update the 810 * cursor location. 811 */ 812 mvcur(_cursesi_screen->curscr->cury, 813 _cursesi_screen->curscr->curx, 814 win->cury + win->begy, win->curx + win->begx); 815 _cursesi_screen->curscr->cury = 816 win->cury + win->begy; 817 _cursesi_screen->curscr->curx = 818 win->curx + win->begx; 819 } 820 } 821 822 __CTRACE(__CTRACE_INPUT, "wgetch: __echoit = %d, " 823 "__rawmode = %d, __nl = %d, flags = %#.4x, delay = %d\n", 824 __echoit, __rawmode, _cursesi_screen->nl, win->flags, win->delay); 825 if (_cursesi_screen->resized) { 826 resizeterm(LINES, COLS); 827 _cursesi_screen->resized = 0; 828 __CTRACE(__CTRACE_INPUT, "wgetch returning KEY_RESIZE\n"); 829 return KEY_RESIZE; 830 } 831 if (_cursesi_screen->unget_pos) { 832 __CTRACE(__CTRACE_INPUT, "wgetch returning char at %d\n", 833 _cursesi_screen->unget_pos); 834 _cursesi_screen->unget_pos--; 835 c = _cursesi_screen->unget_list[_cursesi_screen->unget_pos]; 836 if (__echoit) 837 waddch(win, (chtype) c); 838 return c; 839 } 840 if (__echoit && !__rawmode) { 841 cbreak(); 842 weset = 1; 843 } else 844 weset = 0; 845 846 __save_termios(); 847 848 if (win->flags & __KEYPAD) { 849 switch (win->delay) { 850 case -1: 851 inp = inkey (win->flags & __NOTIMEOUT ? 0 : 1, 0); 852 break; 853 case 0: 854 if (__nodelay() == ERR) 855 return ERR; 856 inp = inkey(0, 0); 857 break; 858 default: 859 inp = inkey(win->flags & __NOTIMEOUT ? 0 : 1, win->delay); 860 break; 861 } 862 } else { 863 switch (win->delay) { 864 case -1: 865 if (__delay() == ERR) 866 return ERR; 867 break; 868 case 0: 869 if (__nodelay() == ERR) 870 return ERR; 871 break; 872 default: 873 if (__timeout(win->delay) == ERR) 874 return ERR; 875 break; 876 } 877 878 inp = __fgetc_resize(infd); 879 if (inp == ERR || inp == KEY_RESIZE) { 880 clearerr(infd); 881 __restore_termios(); 882 return inp; 883 } 884 } 885 #ifdef DEBUG 886 if (inp > 255) 887 /* we have a key symbol - treat it differently */ 888 /* XXXX perhaps __unctrl should be expanded to include 889 * XXXX the keysyms in the table.... 890 */ 891 __CTRACE(__CTRACE_INPUT, "wgetch assembled keysym 0x%x\n", inp); 892 else 893 __CTRACE(__CTRACE_INPUT, "wgetch got '%s'\n", unctrl(inp)); 894 #endif 895 if (win->delay > -1) { 896 if (__delay() == ERR) 897 return ERR; 898 } 899 900 __restore_termios(); 901 902 if ((__echoit) && (inp < KEY_MIN)) 903 waddch(win, (chtype) inp); 904 905 if (weset) 906 nocbreak(); 907 908 if (_cursesi_screen->nl && inp == 13) 909 inp = 10; 910 911 return ((inp < 0) || (inp == ERR) ? ERR : inp); 912 } 913 914 /* 915 * ungetch -- 916 * Put the character back into the input queue. 917 */ 918 int 919 ungetch(int c) 920 { 921 return __unget((wint_t)c); 922 } 923 924 /* 925 * __unget -- 926 * Do the work for ungetch() and unget_wch(); 927 */ 928 int 929 __unget(wint_t c) 930 { 931 wchar_t *p; 932 int len; 933 934 __CTRACE(__CTRACE_INPUT, "__unget(%x)\n", c); 935 if (_cursesi_screen == NULL) 936 return ERR; 937 if (_cursesi_screen->unget_pos >= _cursesi_screen->unget_len) { 938 len = _cursesi_screen->unget_len + 32; 939 if ((p = realloc(_cursesi_screen->unget_list, 940 sizeof(wchar_t) * len)) == NULL) { 941 /* Can't realloc(), so just lose the oldest entry */ 942 memmove(_cursesi_screen->unget_list, 943 _cursesi_screen->unget_list + sizeof(wchar_t), 944 _cursesi_screen->unget_len - 1); 945 _cursesi_screen->unget_list[_cursesi_screen->unget_len 946 - 1] = c; 947 _cursesi_screen->unget_pos = 948 _cursesi_screen->unget_len; 949 return OK; 950 } else { 951 _cursesi_screen->unget_pos = 952 _cursesi_screen->unget_len; 953 _cursesi_screen->unget_len = len; 954 _cursesi_screen->unget_list = p; 955 } 956 } 957 _cursesi_screen->unget_list[_cursesi_screen->unget_pos] = c; 958 _cursesi_screen->unget_pos++; 959 return OK; 960 } 961 962 int 963 has_key(int key_type) 964 { 965 int result = ERR; 966 967 if (_cursesi_screen != NULL) 968 do_keyok(_cursesi_screen->base_keymap, key_type, 969 false, false, &result); 970 return result; 971 } 972 973 /* 974 * set_escdelay -- 975 * Sets the escape delay for the current screen. 976 */ 977 int 978 set_escdelay(int escdelay) 979 { 980 981 if (_cursesi_screen == NULL) 982 return ERR; 983 _cursesi_screen->ESCDELAY = escdelay; 984 ESCDELAY = escdelay; 985 return OK; 986 } 987 988 /* 989 * __fgetc_resize -- 990 * Any call to fgetc(3) should use this function instead 991 * and test for the return value of KEY_RESIZE as well as ERR. 992 */ 993 int 994 __fgetc_resize(FILE *infd) 995 { 996 int c; 997 998 c = fgetc(infd); 999 if (c != EOF) 1000 return c; 1001 1002 if (!ferror(infd) || errno != EINTR || !_cursesi_screen->resized) 1003 return ERR; 1004 __CTRACE(__CTRACE_INPUT, "__fgetc_resize returning KEY_RESIZE\n"); 1005 resizeterm(LINES, COLS); 1006 _cursesi_screen->resized = 0; 1007 return KEY_RESIZE; 1008 } 1009
Indexes created Fri Sep 26 20:09:58 GMT 2025