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