getch.c revision 1.35 
1/*	$NetBSD: getch.c,v 1.35 2001/12/02 09:14:21 blymn 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. All advertising materials mentioning features or use of this software
16 *    must display the following acknowledgement:
17 *	This product includes software developed by the University of
18 *	California, Berkeley and its contributors.
19 * 4. Neither the name of the University nor the names of its contributors
20 *    may be used to endorse or promote products derived from this software
21 *    without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 */
35
36#include <sys/cdefs.h>
37#ifndef lint
38#if 0
39static char sccsid[] = "@(#)getch.c	8.2 (Berkeley) 5/4/94";
40#else
41__RCSID("$NetBSD: getch.c,v 1.35 2001/12/02 09:14:21 blymn Exp $");
42#endif
43#endif					/* not lint */
44
45#include <string.h>
46#include <stdlib.h>
47#include <unistd.h>
48#include <stdio.h>
49#include "curses.h"
50#include "curses_private.h"
51
52#define DEFAULT_DELAY 2			/* default delay for timeout() */
53
54/*
55 * Keyboard input handler.  Do this by snarfing
56 * all the info we can out of the termcap entry for TERM and putting it
57 * into a set of keymaps.  A keymap is an array the size of all the possible
58 * single characters we can get, the contents of the array is a structure
59 * that contains the type of entry this character is (i.e. part/end of a
60 * multi-char sequence or a plain char) and either a pointer which will point
61 * to another keymap (in the case of a multi-char sequence) OR the data value
62 * that this key should return.
63 *
64 */
65
66/* private data structures for holding the key definitions */
67typedef struct key_entry key_entry_t;
68
69struct key_entry {
70	short   type;		/* type of key this is */
71	union {
72		keymap_t *next;	/* next keymap is key is multi-key sequence */
73		wchar_t   symbol;	/* key symbol if key is a leaf entry */
74	} value;
75};
76/* Types of key structures we can have */
77#define KEYMAP_MULTI  1		/* part of a multi char sequence */
78#define KEYMAP_LEAF   2		/* key has a symbol associated with it, either
79				 * it is the end of a multi-char sequence or a
80				 * single char key that generates a symbol */
81
82/* allocate this many key_entry structs at once to speed start up must
83 * be a power of 2.
84 */
85#define KEYMAP_ALLOC_CHUNK 4
86
87/* The max number of different chars we can receive */
88#define MAX_CHAR 256
89
90struct keymap {
91	int	count;		/* count of number of key structs allocated */
92	short	mapping[MAX_CHAR]; /* mapping of key to allocated structs */
93	key_entry_t **key;	/* dynamic array of keys */
94};
95
96
97/* Key buffer */
98#define INBUF_SZ 16		/* size of key buffer - must be larger than
99				 * longest multi-key sequence */
100static wchar_t  inbuf[INBUF_SZ];
101static int     start, end, working; /* pointers for manipulating inbuf data */
102
103#define INC_POINTER(ptr)  do {	\
104	(ptr)++;		\
105	ptr %= INBUF_SZ;	\
106} while(/*CONSTCOND*/0)
107
108static short	state;		/* state of the inkey function */
109
110#define INKEY_NORM	 0	/* no key backlog to process */
111#define INKEY_ASSEMBLING 1	/* assembling a multi-key sequence */
112#define INKEY_BACKOUT	 2	/* recovering from an unrecognised key */
113#define INKEY_TIMEOUT	 3	/* multi-key sequence timeout */
114
115/* The termcap data we are interested in and the symbols they map to */
116struct tcdata {
117	const char	*name;	/* name of termcap entry */
118	wchar_t	symbol;		/* the symbol associated with it */
119};
120
121static const struct tcdata tc[] = {
122	{"!1", KEY_SSAVE},
123	{"!2", KEY_SSUSPEND},
124	{"!3", KEY_SUNDO},
125	{"#1", KEY_SHELP},
126	{"#2", KEY_SHOME},
127	{"#3", KEY_SIC},
128	{"#4", KEY_SLEFT},
129	{"%0", KEY_REDO},
130	{"%1", KEY_HELP},
131	{"%2", KEY_MARK},
132	{"%3", KEY_MESSAGE},
133	{"%4", KEY_MOVE},
134	{"%5", KEY_NEXT},
135	{"%6", KEY_OPEN},
136	{"%7", KEY_OPTIONS},
137	{"%8", KEY_PREVIOUS},
138	{"%9", KEY_PRINT},
139	{"%a", KEY_SMESSAGE},
140	{"%b", KEY_SMOVE},
141	{"%c", KEY_SNEXT},
142	{"%d", KEY_SOPTIONS},
143	{"%e", KEY_SPREVIOUS},
144	{"%f", KEY_SPRINT},
145	{"%g", KEY_SREDO},
146	{"%h", KEY_SREPLACE},
147	{"%i", KEY_SRIGHT},
148	{"%j", KEY_SRSUME},
149	{"&0", KEY_SCANCEL},
150	{"&1", KEY_REFERENCE},
151	{"&2", KEY_REFRESH},
152	{"&3", KEY_REPLACE},
153	{"&4", KEY_RESTART},
154	{"&5", KEY_RESUME},
155	{"&6", KEY_SAVE},
156	{"&7", KEY_SUSPEND},
157	{"&8", KEY_UNDO},
158	{"&9", KEY_SBEG},
159	{"*0", KEY_SFIND},
160	{"*1", KEY_SCOMMAND},
161	{"*2", KEY_SCOPY},
162	{"*3", KEY_SCREATE},
163	{"*4", KEY_SDC},
164	{"*5", KEY_SDL},
165	{"*6", KEY_SELECT},
166	{"*7", KEY_SEND},
167	{"*8", KEY_SEOL},
168	{"*9", KEY_SEXIT},
169	{"@0", KEY_FIND},
170	{"@1", KEY_BEG},
171	{"@2", KEY_CANCEL},
172	{"@3", KEY_CLOSE},
173	{"@4", KEY_COMMAND},
174	{"@5", KEY_COPY},
175	{"@6", KEY_CREATE},
176	{"@7", KEY_END},
177	{"@8", KEY_ENTER},
178	{"@9", KEY_EXIT},
179	{"F1", KEY_F(11)},
180	{"F2", KEY_F(12)},
181	{"F3", KEY_F(13)},
182	{"F4", KEY_F(14)},
183	{"F5", KEY_F(15)},
184	{"F6", KEY_F(16)},
185	{"F7", KEY_F(17)},
186	{"F8", KEY_F(18)},
187	{"F9", KEY_F(19)},
188	{"FA", KEY_F(20)},
189	{"FB", KEY_F(21)},
190	{"FC", KEY_F(22)},
191	{"FD", KEY_F(23)},
192	{"FE", KEY_F(24)},
193	{"FF", KEY_F(25)},
194	{"FG", KEY_F(26)},
195	{"FH", KEY_F(27)},
196	{"FI", KEY_F(28)},
197	{"FJ", KEY_F(29)},
198	{"FK", KEY_F(30)},
199	{"FL", KEY_F(31)},
200	{"FM", KEY_F(32)},
201	{"FN", KEY_F(33)},
202	{"FO", KEY_F(34)},
203	{"FP", KEY_F(35)},
204	{"FQ", KEY_F(36)},
205	{"FR", KEY_F(37)},
206	{"FS", KEY_F(38)},
207	{"FT", KEY_F(39)},
208	{"FU", KEY_F(40)},
209	{"FV", KEY_F(41)},
210	{"FW", KEY_F(42)},
211	{"FX", KEY_F(43)},
212	{"FY", KEY_F(44)},
213	{"FZ", KEY_F(45)},
214	{"Fa", KEY_F(46)},
215	{"Fb", KEY_F(47)},
216	{"Fc", KEY_F(48)},
217	{"Fd", KEY_F(49)},
218	{"Fe", KEY_F(50)},
219	{"Ff", KEY_F(51)},
220	{"Fg", KEY_F(52)},
221	{"Fh", KEY_F(53)},
222	{"Fi", KEY_F(54)},
223	{"Fj", KEY_F(55)},
224	{"Fk", KEY_F(56)},
225	{"Fl", KEY_F(57)},
226	{"Fm", KEY_F(58)},
227	{"Fn", KEY_F(59)},
228	{"Fo", KEY_F(60)},
229	{"Fp", KEY_F(61)},
230	{"Fq", KEY_F(62)},
231	{"Fr", KEY_F(63)},
232	{"K1", KEY_A1},
233	{"K2", KEY_B2},
234	{"K3", KEY_A3},
235	{"K4", KEY_C1},
236	{"K5", KEY_C3},
237	{"Km", KEY_MOUSE},
238	{"k0", KEY_F0},
239	{"k1", KEY_F(1)},
240	{"k2", KEY_F(2)},
241	{"k3", KEY_F(3)},
242	{"k4", KEY_F(4)},
243	{"k5", KEY_F(5)},
244	{"k6", KEY_F(6)},
245	{"k7", KEY_F(7)},
246	{"k8", KEY_F(8)},
247	{"k9", KEY_F(9)},
248	{"k;", KEY_F(10)},
249	{"kA", KEY_IL},
250	{"ka", KEY_CATAB},
251	{"kB", KEY_BTAB},
252	{"kb", KEY_BACKSPACE},
253	{"kC", KEY_CLEAR},
254	{"kD", KEY_DC},
255	{"kd", KEY_DOWN},
256	{"kE", KEY_EOL},
257	{"kF", KEY_SF},
258	{"kH", KEY_LL},
259	{"kh", KEY_HOME},
260	{"kI", KEY_IC},
261	{"kL", KEY_DL},
262	{"kl", KEY_LEFT},
263	{"kM", KEY_EIC},
264	{"kN", KEY_NPAGE},
265	{"kP", KEY_PPAGE},
266	{"kR", KEY_SR},
267	{"kr", KEY_RIGHT},
268	{"kS", KEY_EOS},
269	{"kT", KEY_STAB},
270	{"kt", KEY_CTAB},
271	{"ku", KEY_UP}
272};
273/* Number of TC entries .... */
274static const int num_tcs = (sizeof(tc) / sizeof(struct tcdata));
275
276/* prototypes for private functions */
277static key_entry_t *add_new_key(keymap_t *current, char chr, int key_type,
278				int symbol);
279static keymap_t		*new_keymap(void);	/* create a new keymap */
280static key_entry_t	*new_key(void);		/* create a new key entry */
281static wchar_t		inkey(int to, int delay);
282
283/*
284 * Free the storage associated with the given keymap
285 */
286void
287_cursesi_free_keymap(keymap_t *map)
288{
289	int i;
290
291	  /* check for, and free, child keymaps */
292	for (i = 0; i < MAX_CHAR; i++) {
293		if (map->mapping[i] >= 0) {
294			if (map->key[map->mapping[i]]->type == KEYMAP_MULTI)
295				_cursesi_free_keymap(
296					map->key[map->mapping[i]]->value.next);
297		}
298	}
299
300	  /* now free any allocated keymap structs */
301	for (i = 0; i < map->count; i += KEYMAP_ALLOC_CHUNK) {
302		free(map->key[i]);
303	}
304
305	free(map->key);
306	free(map);
307}
308
309
310/*
311 * Add a new key entry to the keymap pointed to by current.  Entry
312 * contains the character to add to the keymap, type is the type of
313 * entry to add (either multikey or leaf) and symbol is the symbolic
314 * value for a leaf type entry.  The function returns a pointer to the
315 * new keymap entry.
316 */
317static key_entry_t *
318add_new_key(keymap_t *current, char chr, int key_type, int symbol)
319{
320	key_entry_t *the_key;
321        int i;
322
323#ifdef DEBUG
324	__CTRACE("Adding character %s of type %d, symbol 0x%x\n", unctrl(chr),
325		 key_type, symbol);
326#endif
327	if (current->mapping[(unsigned char) chr] < 0) {
328		  /* first time for this char */
329		current->mapping[(unsigned char) chr] = current->count;	/* map new entry */
330		  /* make sure we have room in the key array first */
331		if ((current->count & (KEYMAP_ALLOC_CHUNK - 1)) == 0)
332		{
333			if ((current->key =
334			     realloc(current->key,
335				     (current->count) * sizeof(key_entry_t *)
336				     + KEYMAP_ALLOC_CHUNK * sizeof(key_entry_t *))) == NULL) {
337				fprintf(stderr,
338					"Could not malloc for key entry\n");
339				exit(1);
340			}
341
342			the_key = new_key();
343                        for (i = 0; i < KEYMAP_ALLOC_CHUNK; i++) {
344                                current->key[current->count + i]
345					= &the_key[i];
346                        }
347                }
348
349                  /* point at the current key array element to use */
350                the_key = current->key[current->count];
351
352		the_key->type = key_type;
353
354		switch (key_type) {
355		  case KEYMAP_MULTI:
356			    /* need for next key */
357#ifdef DEBUG
358			  __CTRACE("Creating new keymap\n");
359#endif
360			  the_key->value.next = new_keymap();
361			  break;
362
363		  case KEYMAP_LEAF:
364				/* the associated symbol for the key */
365#ifdef DEBUG
366			  __CTRACE("Adding leaf key\n");
367#endif
368			  the_key->value.symbol = symbol;
369			  break;
370
371		  default:
372			  fprintf(stderr, "add_new_key: bad type passed\n");
373			  exit(1);
374		}
375
376		current->count++;
377	} else {
378		  /* the key is already known - just return the address. */
379#ifdef DEBUG
380		__CTRACE("Keymap already known\n");
381#endif
382		the_key = current->key[current->mapping[(unsigned char) chr]];
383	}
384
385        return the_key;
386}
387
388/*
389 * Init_getch - initialise all the pointers & structures needed to make
390 * getch work in keypad mode.
391 *
392 */
393void
394__init_getch(SCREEN *screen)
395{
396	char entry[1024], *p;
397	int     i, j, length, key_ent;
398	size_t limit;
399	key_entry_t *tmp_key;
400	keymap_t *current;
401#ifdef DEBUG
402	int k;
403#endif
404
405	/* init the inkey state variable */
406	state = INKEY_NORM;
407
408	/* init the base keymap */
409	screen->base_keymap = new_keymap();
410
411	/* key input buffer pointers */
412	start = end = working = 0;
413
414	/* now do the termcap snarfing ... */
415
416	for (i = 0; i < num_tcs; i++) {
417		p = entry;
418		limit = 1023;
419		if (t_getstr(screen->cursesi_genbuf, tc[i].name,
420			     &p, &limit) != NULL) {
421			current = screen->base_keymap;	/* always start with
422							 * base keymap. */
423			length = (int) strlen(entry);
424#ifdef DEBUG
425			__CTRACE("Processing termcap entry %s, sequence ",
426				 tc[i].name);
427			for (k = 0; k <= length -1; k++)
428				__CTRACE("%s", unctrl(entry[k]));
429			__CTRACE("\n");
430#endif
431			for (j = 0; j < length - 1; j++) {
432				  /* add the entry to the struct */
433				tmp_key = add_new_key(current,
434						      entry[j],
435						      KEYMAP_MULTI, 0);
436
437				  /* index into the key array - it's
438				     clearer if we stash this */
439				key_ent = current->mapping[
440					(unsigned char) entry[j]];
441
442				current->key[key_ent] = tmp_key;
443
444				  /* next key uses this map... */
445				current = current->key[key_ent]->value.next;
446			}
447
448				/* this is the last key in the sequence (it
449				 * may have been the only one but that does
450				 * not matter) this means it is a leaf key and
451				 * should have a symbol associated with it.
452				 */
453			tmp_key = add_new_key(current,
454					      entry[length - 1],
455					      KEYMAP_LEAF,
456					      tc[i].symbol);
457			current->key[
458				current->mapping[(int)entry[length - 1]]] =
459			tmp_key;
460		}
461	}
462}
463
464
465/*
466 * new_keymap - allocates & initialises a new keymap structure.  This
467 * function returns a pointer to the new keymap.
468 *
469 */
470static keymap_t *
471new_keymap(void)
472{
473	int     i;
474	keymap_t *new_map;
475
476	if ((new_map = malloc(sizeof(keymap_t))) == NULL) {
477		perror("Inkey: Cannot allocate new keymap");
478		exit(2);
479	}
480
481	/* Initialise the new map */
482	new_map->count = 0;
483	for (i = 0; i < MAX_CHAR; i++) {
484		new_map->mapping[i] = -1;	/* no mapping for char */
485	}
486
487	/* key array will be allocated when first key is added */
488	new_map->key = NULL;
489
490	return new_map;
491}
492
493/*
494 * new_key - allocates & initialises a new key entry.  This function returns
495 * a pointer to the newly allocated key entry.
496 *
497 */
498static key_entry_t *
499new_key(void)
500{
501	key_entry_t *new_one;
502	int i;
503
504	if ((new_one = malloc(KEYMAP_ALLOC_CHUNK * sizeof(key_entry_t)))
505	    == NULL) {
506		perror("inkey: Cannot allocate new key entry chunk");
507		exit(2);
508	}
509
510	for (i = 0; i < KEYMAP_ALLOC_CHUNK; i++) {
511		new_one[i].type = 0;
512		new_one[i].value.next = NULL;
513	}
514
515	return new_one;
516}
517
518/*
519 * inkey - do the work to process keyboard input, check for multi-key
520 * sequences and return the appropriate symbol if we get a match.
521 *
522 */
523
524wchar_t
525inkey(int to, int delay)
526{
527	wchar_t		 k;
528	int              c;
529	keymap_t	*current = _cursesi_screen->base_keymap;
530	FILE            *infd = _cursesi_screen->infd;
531
532	k = 0;		/* XXX gcc -Wuninitialized */
533
534	for (;;) {		/* loop until we get a complete key sequence */
535reread:
536		if (state == INKEY_NORM) {
537			if (delay && __timeout(delay) == ERR)
538				return ERR;
539			if ((c = getchar()) == EOF) {
540				clearerr(infd);
541				return ERR;
542			}
543
544			if (delay && (__notimeout() == ERR))
545				return ERR;
546
547			k = (wchar_t) c;
548#ifdef DEBUG
549			__CTRACE("inkey (state normal) got '%s'\n", unctrl(k));
550#endif
551
552			working = start;
553			inbuf[working] = k;
554			INC_POINTER(working);
555			end = working;
556			state = INKEY_ASSEMBLING;	/* go to the assembling
557							 * state now */
558		} else if (state == INKEY_BACKOUT) {
559			k = inbuf[working];
560			INC_POINTER(working);
561			if (working == end) {	/* see if we have run
562						 * out of keys in the
563						 * backlog */
564
565				/* if we have then switch to
566				   assembling */
567				state = INKEY_ASSEMBLING;
568			}
569		} else if (state == INKEY_ASSEMBLING) {
570			/* assembling a key sequence */
571			if (delay) {
572				if (__timeout(to ? DEFAULT_DELAY : delay) == ERR)
573						return ERR;
574			} else {
575				if (to && (__timeout(DEFAULT_DELAY) == ERR))
576					return ERR;
577			}
578
579			c = getchar();
580			if (ferror(infd)) {
581				clearerr(infd);
582				return ERR;
583			}
584
585			if ((to || delay) && (__notimeout() == ERR))
586					return ERR;
587
588			k = (wchar_t) c;
589#ifdef DEBUG
590			__CTRACE("inkey (state assembling) got '%s'\n", unctrl(k));
591#endif
592			if (feof(infd)) {	/* inter-char timeout,
593						 * start backing out */
594				clearerr(infd);
595				if (start == end)
596					/* no chars in the buffer, restart */
597					goto reread;
598
599				k = inbuf[start];
600				state = INKEY_TIMEOUT;
601			} else {
602				inbuf[working] = k;
603				INC_POINTER(working);
604				end = working;
605			}
606		} else {
607			fprintf(stderr, "Inkey state screwed - exiting!!!");
608			exit(2);
609		}
610
611		/* Check key has no special meaning and we have not timed out */
612		if ((state == INKEY_TIMEOUT) || (current->mapping[k] < 0)) {
613			/* return the first key we know about */
614			k = inbuf[start];
615
616			INC_POINTER(start);
617			working = start;
618
619			if (start == end) {	/* only one char processed */
620				state = INKEY_NORM;
621			} else {/* otherwise we must have more than one char
622				 * to backout */
623				state = INKEY_BACKOUT;
624			}
625			return k;
626		} else {	/* must be part of a multikey sequence */
627			/* check for completed key sequence */
628			if (current->key[current->mapping[k]]->type == KEYMAP_LEAF) {
629				start = working;	/* eat the key sequence
630							 * in inbuf */
631
632				/* check if inbuf empty now */
633				if (start == end) {
634					/* if it is go back to normal */
635					state = INKEY_NORM;
636				} else {
637					/* otherwise go to backout state */
638					state = INKEY_BACKOUT;
639				}
640
641				/* return the symbol */
642				return current->key[current->mapping[k]]->value.symbol;
643
644			} else {
645				/*
646				 * Step on to next part of the multi-key
647				 * sequence.
648				 */
649				current = current->key[current->mapping[k]]->value.next;
650			}
651		}
652	}
653}
654
655#ifndef _CURSES_USE_MACROS
656/*
657 * getch --
658 *	Read in a character from stdscr.
659 */
660int
661getch(void)
662{
663	return wgetch(stdscr);
664}
665
666/*
667 * mvgetch --
668 *      Read in a character from stdscr at the given location.
669 */
670int
671mvgetch(int y, int x)
672{
673	return mvwgetch(stdscr, y, x);
674}
675
676/*
677 * mvwgetch --
678 *      Read in a character from stdscr at the given location in the
679 *      given window.
680 */
681int
682mvwgetch(WINDOW *win, int y, int x)
683{
684	if (wmove(win, y, x) == ERR)
685		return ERR;
686
687	return wgetch(win);
688}
689
690#endif
691
692/*
693 * wgetch --
694 *	Read in a character from the window.
695 */
696int
697wgetch(WINDOW *win)
698{
699	int inp, weset;
700	int c;
701	FILE *infd = _cursesi_screen->infd;
702
703	if (!(win->flags & __SCROLLOK) && (win->flags & __FULLWIN)
704	    && win->curx == win->maxx - 1 && win->cury == win->maxy - 1
705	    && __echoit)
706		return (ERR);
707
708	if (is_wintouched(win))
709		wrefresh(win);
710#ifdef DEBUG
711	__CTRACE("wgetch: __echoit = %d, __rawmode = %d, flags = %0.2o\n",
712	    __echoit, __rawmode, win->flags);
713#endif
714	if (__echoit && !__rawmode) {
715		cbreak();
716		weset = 1;
717	} else
718		weset = 0;
719
720	__save_termios();
721
722	if (win->flags & __KEYPAD) {
723		switch (win->delay)
724		{
725		case -1:
726			inp = inkey (win->flags & __NOTIMEOUT ? 0 : 1, 0);
727			break;
728		case 0:
729			if (__nodelay() == ERR) {
730				__restore_termios();
731				return ERR;
732			}
733			inp = inkey(0, 0);
734			break;
735		default:
736			inp = inkey(win->flags & __NOTIMEOUT ? 0 : 1, win->delay);
737			break;
738		}
739	} else {
740		switch (win->delay)
741		{
742		case -1:
743			break;
744		case 0:
745			if (__nodelay() == ERR) {
746				__restore_termios();
747				return ERR;
748			}
749			break;
750		default:
751			if (__timeout(win->delay) == ERR) {
752				__restore_termios();
753				return ERR;
754			}
755			break;
756		}
757
758		c = getchar();
759		if (feof(infd)) {
760			clearerr(infd);
761			__restore_termios();
762			return ERR;	/* we have timed out */
763		}
764
765		if (ferror(infd)) {
766			clearerr(infd);
767			inp = ERR;
768		} else {
769			inp = c;
770		}
771	}
772#ifdef DEBUG
773	if (inp > 255)
774		  /* we have a key symbol - treat it differently */
775		  /* XXXX perhaps __unctrl should be expanded to include
776		   * XXXX the keysyms in the table....
777		   */
778		__CTRACE("wgetch assembled keysym 0x%x\n", inp);
779	else
780		__CTRACE("wgetch got '%s'\n", unctrl(inp));
781#endif
782	if (win->delay > -1) {
783		if (__delay() == ERR) {
784			__restore_termios();
785			return ERR;
786		}
787	}
788
789	__restore_termios();
790
791	if (__echoit)
792		waddch(win, (chtype) inp);
793
794	if (weset)
795		nocbreak();
796
797	return ((inp < 0) || (inp == ERR) ? ERR : inp);
798}
799
800/*
801 * ungetch --
802 *     Put the character back into the input queue.
803 */
804int
805ungetch(int c)
806{
807	return ((ungetc(c, _cursesi_screen->infd) == EOF) ? ERR : OK);
808}
809