path: root/private/crt32/lowio/getch.c

/***
*getch.c - contains _getch(), _getche(), _ungetch() and kbhit for Windows NT
*
*	Copyright (c) 1989-1993, Microsoft Corporation. All rights reserved.
*
*Purpose:
*	Defines the "direct console" functions listed above.
*
*	NOTE: The real-mode DOS versions of these functions read from
*	standard input and are therefore redirected when standard input
*	is redirected. However, these versions ALWAYS read from the console,
*	even when standard input is redirected.
*
*Revision History:
*	06-08-89  PHG	Module created, based on asm version
*	03-12-90  GJF	Made calling type _CALLTYPE1, added #include
*			<cruntime.h> and fixed the copyright. Also, cleaned
*			up the formatting a bit.
*	06-05-90  SBM	Recoded as pure 32-bit, using new file handle state bits
*	07-24-90  SBM	Removed '32' from API names
*	10-03-90  GJF	New-style function declarators.
*	12-04-90  SRW	Changed to include <oscalls.h> instead of <doscalls.h>
*	12-06-90  SRW	Added _CRUISER_ and _WIN32 conditionals.
*	01-16-91  GJF	ANSI naming.
*	01-25-91  SRW	Get/SetConsoleMode parameters changed (_WIN32_)
*	02-18-91  SRW	Get/SetConsoleMode required read/write access (_WIN32_)
*	02-19-91  SRW	Adapt to OpenFile/CreateFile changes (_WIN32_)
*	02-25-91  MHL	Adapt to ReadFile/WriteFile changes (_WIN32_)
*	07-26-91  GJF	Took out init. stuff and cleaned up the error
*			handling [_WIN32_].
*	12-11-92  GJF	Initialize character buffer to 0 (int ch = 0;) and
*			use ReadConsole instead of ReadFile.
*	03-20-93  GJF	Completely rewritten, Cruiser support purged, _kbhit
*			(also rewritten) and _ungetch also merged in.
*	05-10-93  GJF	Fixed bug in _kbhit, pointer passed to free no
*			longer pointed to the allocated block.
*
*******************************************************************************/

#include <cruntime.h>
#include <oscalls.h>
#include <conio.h>
#include <os2dll.h>
#include <stdio.h>
#include <stdlib.h>

typedef struct {
	unsigned char LeadChar;
	unsigned char SecondChar;
	} CharPair;

typedef struct {
	unsigned short ScanCode;
	CharPair RegChars;
	CharPair ShiftChars;
	CharPair CtrlChars;
	CharPair AltChars;
	} EnhKeyVals;

typedef struct {
	CharPair RegChars;
	CharPair ShiftChars;
	CharPair CtrlChars;
	CharPair AltChars;
	} NormKeyVals;

/*
 * Table of key values for enhanced keys
 */
static EnhKeyVals EnhancedKeys[] = {
	{ 28, {  13,   0 }, {  13,   0 }, {  10,   0 }, {   0, 166 } },
	{ 53, {  47,   0 }, {  63,   0 }, {   0, 149 }, {   0, 164 } },
	{ 71, { 224,  71 }, { 224,  71 }, { 224, 119 }, {   0, 151 } },
	{ 72, { 224,  72 }, { 224,  72 }, { 224, 141 }, {   0, 152 } },
	{ 73, { 224,  73 }, { 224,  73 }, { 224, 134 }, {   0, 153 } },
	{ 75, { 224,  75 }, { 224,  75 }, { 224, 115 }, {   0, 155 } },
	{ 77, { 224,  77 }, { 224,  77 }, { 224, 116 }, {   0, 157 } },
	{ 79, { 224,  79 }, { 224,  79 }, { 224, 117 }, {   0, 159 } },
	{ 80, { 224,  80 }, { 224,  80 }, { 224, 145 }, {   0, 160 } },
	{ 81, { 224,  81 }, { 224,  81 }, { 224, 118 }, {   0, 161 } },
	{ 82, { 224,  82 }, { 224,  82 }, { 224, 146 }, {   0, 162 } },
	{ 83, { 224,  83 }, { 224,  83 }, { 224, 147 }, {   0, 163 } }
	};

/*
 * macro for the number of elements of in EnhancedKeys[]
 */
#define NUM_EKA_ELTS	( sizeof( EnhancedKeys ) / sizeof( EnhKeyVals ) )

/*
 * Table of key values for normal keys. Note that the table is padded so
 * that the key scan code serves as an index into the table.
 */
static NormKeyVals NormalKeys[] = {

	/* padding */
	{ /*  0 */ {   0,   0 }, {   0,	  0 }, {   0,	0 }, {	 0,   0 } },

	{ /*  1 */ {  27,   0 }, {  27,	  0 }, {  27,	0 }, {	 0,   1 } },
	{ /*  2 */ {  49,   0 }, {  33,	  0 }, {   0,	0 }, {	 0, 120 } },
	{ /*  3 */ {  50,   0 }, {  64,	  0 }, {   0,	3 }, {	 0, 121 } },
	{ /*  4 */ {  51,   0 }, {  35,	  0 }, {   0,	0 }, {	 0, 122 } },
	{ /*  5 */ {  52,   0 }, {  36,	  0 }, {   0,	0 }, {	 0, 123 } },
	{ /*  6 */ {  53,   0 }, {  37,	  0 }, {   0,	0 }, {	 0, 124 } },
	{ /*  7 */ {  54,   0 }, {  94,	  0 }, {  30,	0 }, {	 0, 125 } },
	{ /*  8 */ {  55,   0 }, {  38,	  0 }, {   0,	0 }, {	 0, 126 } },
	{ /*  9 */ {  56,   0 }, {  42,	  0 }, {   0,	0 }, {	 0, 127 } },
	{ /* 10 */ {  57,   0 }, {  40,	  0 }, {   0,	0 }, {	 0, 128 } },
	{ /* 11 */ {  48,   0 }, {  41,	  0 }, {   0,	0 }, {	 0, 129 } },
	{ /* 12 */ {  45,   0 }, {  95,	  0 }, {  31,	0 }, {	 0, 130 } },
	{ /* 13 */ {  61,   0 }, {  43,	  0 }, {   0,	0 }, {	 0, 131 } },
	{ /* 14 */ {   8,   0 }, {   8,	  0 }, { 127,	0 }, {	 0,  14 } },
	{ /* 15 */ {   9,   0 }, {   0,	 15 }, {   0, 148 }, {	 0,  15 } },
	{ /* 16 */ { 113,   0 }, {  81,	  0 }, {  17,	0 }, {	 0,  16 } },
	{ /* 17 */ { 119,   0 }, {  87,	  0 }, {  23,	0 }, {	 0,  17 } },
	{ /* 18 */ { 101,   0 }, {  69,	  0 }, {   5,	0 }, {	 0,  18 } },
	{ /* 19 */ { 114,   0 }, {  82,	  0 }, {  18,	0 }, {	 0,  19 } },
	{ /* 20 */ { 116,   0 }, {  84,	  0 }, {  20,	0 }, {	 0,  20 } },
	{ /* 21 */ { 121,   0 }, {  89,	  0 }, {  25,	0 }, {	 0,  21 } },
	{ /* 22 */ { 117,   0 }, {  85,	  0 }, {  21,	0 }, {	 0,  22 } },
	{ /* 23 */ { 105,   0 }, {  73,	  0 }, {   9,	0 }, {	 0,  23 } },
	{ /* 24 */ { 111,   0 }, {  79,	  0 }, {  15,	0 }, {	 0,  24 } },
	{ /* 25 */ { 112,   0 }, {  80,	  0 }, {  16,	0 }, {	 0,  25 } },
	{ /* 26 */ {  91,   0 }, { 123,	  0 }, {  27,	0 }, {	 0,  26 } },
	{ /* 27 */ {  93,   0 }, { 125,	  0 }, {  29,	0 }, {	 0,  27 } },
	{ /* 28 */ {  13,   0 }, {  13,	  0 }, {  10,	0 }, {	 0,  28 } },

	/* padding */
	{ /* 29 */ {   0,   0 }, {   0,	  0 }, {   0,	0 }, {	 0,   0 } },

	{ /* 30 */ {  97,   0 }, {  65,	  0 }, {   1,	0 }, {	 0,  30 } },
	{ /* 31 */ { 115,   0 }, {  83,	  0 }, {  19,	0 }, {	 0,  31 } },
	{ /* 32 */ { 100,   0 }, {  68,	  0 }, {   4,	0 }, {	 0,  32 } },
	{ /* 33 */ { 102,   0 }, {  70,	  0 }, {   6,	0 }, {	 0,  33 } },
	{ /* 34 */ { 103,   0 }, {  71,	  0 }, {   7,	0 }, {	 0,  34 } },
	{ /* 35 */ { 104,   0 }, {  72,	  0 }, {   8,	0 }, {	 0,  35 } },
	{ /* 36 */ { 106,   0 }, {  74,	  0 }, {  10,	0 }, {	 0,  36 } },
	{ /* 37 */ { 107,   0 }, {  75,	  0 }, {  11,	0 }, {	 0,  37 } },
	{ /* 38 */ { 108,   0 }, {  76,	  0 }, {  12,	0 }, {	 0,  38 } },
	{ /* 39 */ {  59,   0 }, {  58,	  0 }, {   0,	0 }, {	 0,  39 } },
	{ /* 40 */ {  39,   0 }, {  34,	  0 }, {   0,	0 }, {	 0,  40 } },
	{ /* 41 */ {  96,   0 }, { 126,	  0 }, {   0,	0 }, {	 0,  41 } },

	/* padding */
	{ /* 42 */ {	0,  0 }, {   0,   0 }, {   0,	0 }, {	 0,   0 } },

	{ /* 43 */ {  92,   0 }, { 124,	  0 }, {  28,	0 }, {	 0,   0 } },
	{ /* 44 */ { 122,   0 }, {  90,	  0 }, {  26,	0 }, {	 0,  44 } },
	{ /* 45 */ { 120,   0 }, {  88,	  0 }, {  24,	0 }, {	 0,  45 } },
	{ /* 46 */ {  99,   0 }, {  67,	  0 }, {   3,	0 }, {	 0,  46 } },
	{ /* 47 */ { 118,   0 }, {  86,	  0 }, {  22,	0 }, {	 0,  47 } },
	{ /* 48 */ {  98,   0 }, {  66,	  0 }, {   2,	0 }, {	 0,  48 } },
	{ /* 49 */ { 110,   0 }, {  78,	  0 }, {  14,	0 }, {	 0,  49 } },
	{ /* 50 */ { 109,   0 }, {  77,	  0 }, {  13,	0 }, {	 0,  50 } },
	{ /* 51 */ {  44,   0 }, {  60,	  0 }, {   0,	0 }, {	 0,  51 } },
	{ /* 52 */ {  46,   0 }, {  62,	  0 }, {   0,	0 }, {	 0,  52 } },
	{ /* 53 */ {  47,   0 }, {  63,	  0 }, {   0,	0 }, {	 0,  53 } },

	/* padding */
	{ /* 54 */ {   0,   0 }, {   0,	  0 }, {   0,	0 }, {	 0,   0 } },

	{ /* 55 */ {  42,   0 }, {   0,	  0 }, { 114,	0 }, {	 0,   0 } },

	/* padding */
	{ /* 56 */ {   0,   0 }, {   0,	  0 }, {   0,	0 }, {	 0,   0 } },

	{ /* 57 */ {  32,   0 }, {  32,	  0 }, {  32,	0 }, {	32,   0 } },

	/* padding */
	{ /* 58 */ {   0,   0 }, {   0,	  0 }, {   0,	0 }, {	 0,   0 } },

	{ /* 59 */ {   0,  59 }, {   0,	 84 }, {   0,  94 }, {	 0, 104 } },
	{ /* 60 */ {   0,  60 }, {   0,	 85 }, {   0,  95 }, {	 0, 105 } },
	{ /* 61 */ {   0,  61 }, {   0,  86 }, {   0,  96 }, {	 0, 106 } },
	{ /* 62 */ {   0,  62 }, {   0,  87 }, {   0,  97 }, {	 0, 107 } },
	{ /* 63 */ {   0,  63 }, {   0,  88 }, {   0,  98 }, {	 0, 108 } },
	{ /* 64 */ {   0,  64 }, {   0,  89 }, {   0,  99 }, {	 0, 109 } },
	{ /* 65 */ {   0,  65 }, {   0,  90 }, {   0, 100 }, {	 0, 110 } },
	{ /* 66 */ {   0,  66 }, {   0,  91 }, {   0, 101 }, {	 0, 111 } },
	{ /* 67 */ {   0,  67 }, {   0,  92 }, {   0, 102 }, {	 0, 112 } },
	{ /* 68 */ {   0,  68 }, {   0,  93 }, {   0, 103 }, {	 0, 113 } },

	/* padding */
	{ /* 69 */ {	0,  0 }, {   0,   0 }, {   0,	0 }, {	 0,   0 } },
	{ /* 70 */ {	0,  0 }, {   0,   0 }, {   0,	0 }, {	 0,   0 } },

	{ /* 71 */ {   0,  71 }, {  55,	  0 }, {   0, 119 }, {	 0,   0 } },
	{ /* 72 */ {   0,  72 }, {  56,	  0 }, {   0, 141 }, {	 0,   0 } },
	{ /* 73 */ {   0,  73 }, {  57,	  0 }, {   0, 132 }, {	 0,   0 } },
	{ /* 74 */ {   0,   0 }, {  45,	  0 }, {   0,	0 }, {	 0,   0 } },
	{ /* 75 */ {   0,  75 }, {  52,	  0 }, {   0, 115 }, {	 0,   0 } },
	{ /* 76 */ {   0,   0 }, {  53,	  0 }, {   0,	0 }, {	 0,   0 } },
	{ /* 77 */ {   0,  77 }, {  54,	  0 }, {   0, 116 }, {	 0,   0 } },
	{ /* 78 */ {   0,   0 }, {  43,	  0 }, {   0,	0 }, {	 0,   0 } },
	{ /* 79 */ {   0,  79 }, {  49,	  0 }, {   0, 117 }, {	 0,   0 } },
	{ /* 80 */ {   0,  80 }, {  50,	  0 }, {   0, 145 }, {	 0,   0 } },
	{ /* 81 */ {   0,  81 }, {  51,	  0 }, {   0, 118 }, {	 0,   0 } },
	{ /* 82 */ {   0,  82 }, {  48,	  0 }, {   0, 146 }, {	 0,   0 } },
	{ /* 83 */ {   0,  83 }, {  46,	  0 }, {   0, 147 }, {	 0,   0 } },

	/* padding */
	{ /* 84 */ {   0,   0 }, {   0,	  0 }, {   0,	0 }, {	 0,   0 } },
	{ /* 85 */ {   0,   0 }, {   0,	  0 }, {   0,	0 }, {	 0,   0 } },
	{ /* 86 */ {   0,   0 }, {   0,	  0 }, {   0,	0 }, {	 0,   0 } },

	{ /* 87 */ { 224, 133 }, { 224, 135 }, { 224, 137 }, { 224, 139 } },
	{ /* 88 */ { 224, 134 }, { 224, 136 }, { 224, 138 }, { 224, 140 } }

};


/*
 * This is the one character push-back buffer used by _getch(), _getche()
 * and _ungetch().
 */
static int chbuf = EOF;


/*
 * Declaration for console handle
 */
extern int _coninpfh;

/*
 * Function that looks up the extended key code for a given event.
 */
static CharPair * _CRTAPI3 GetExtendedKeyCode(KEY_EVENT_RECORD *);


/***
*int _getch(), _getche() - read one char. from console (without and with echo)
*
*Purpose:
*	If the "_ungetch()" push-back buffer is not empty (empty==-1) Then
*	    Mark it empty (-1) and RETURN the value that was in it
*	Read a character using DOSREAD in RAW mode
*	Return the Character Code
*	_getche(): Same as _getch() except that the character value returned
*	is echoed (via "_putch()")
*
*	No _ext_code buffer is required (unlike the DOS & 16 bit OS/2 world,)
*	since OS/2 buffers the extended code for us.
*
*Entry:
*	None, reads from console.
*
*Exit:
*	If an error is returned from the API
*	    Then EOF
*	Otherwise
*	     next byte from console
*	Static variable "chbuf" may be altered
*
*Exceptions:
*
*******************************************************************************/

#ifdef MTHREAD

int _CRTAPI1 _getch (
	void
	)
{
	int ch;

	_mlock(_CONIO_LOCK);		/* secure the console lock */
	ch = _getch_lk();		/* input the character */
	_munlock(_CONIO_LOCK);		/* release the console lock */

	return ch;
}

int _CRTAPI1 _getche (
	void
	)
{
	int ch;

	_mlock(_CONIO_LOCK);		/* secure the console lock */
	ch = _getche_lk();		/* input and echo the character */
	_munlock(_CONIO_LOCK);		/* unlock the console */

	return ch;
}

#endif /* MTHREAD */


#ifdef MTHREAD
int _CRTAPI1 _getch_lk (
#else
int _CRTAPI1 _getch (
#endif
	void
	)
{
	INPUT_RECORD ConInpRec;
	DWORD NumRead;
	CharPair *pCP;
	int ch = 0;			/* single character buffer */
	DWORD oldstate;

	/*
	 * check pushback buffer (chbuf) a for character
	 */
	if ( chbuf != EOF ) {
	    /*
	     * something there, clear buffer and return the character.
	     */
	    ch = (unsigned char)(chbuf & 0xFF);
	    chbuf = EOF;
	    return ch;
	}

	if (_coninpfh == -1)
	    return EOF;

	/*
	 * Switch to raw mode (no line input, no echo input)
	 */
        GetConsoleMode( (HANDLE)_coninpfh, &oldstate );
	SetConsoleMode( (HANDLE)_coninpfh, 0L );

	for ( ; ; ) {

	    /*
	     * Get a console input event.
	     */
	    if ( !ReadConsoleInput( (HANDLE)_coninpfh,
				    &ConInpRec,
				    1L,
				    &NumRead )
		 || (NumRead == 0L) )
	    {
		ch = EOF;
		break;
	    }

	    /*
	     * Look for, and decipher, key events.
	     */
	    if ( (ConInpRec.EventType == KEY_EVENT) &&
		 ConInpRec.Event.KeyEvent.bKeyDown ) {
		/*
		 * Easy case: if uChar.AsciiChar is non-zero, just stuff it
		 * into ch and quit.
		 */
		if ( ch = (unsigned char)ConInpRec.Event.KeyEvent.uChar.AsciiChar )
		    break;

		/*
		 * Hard case: either an extended code or an event which should
		 * not be recognized. let GetExtendedKeyCode() do the work...
		 */
		if ( pCP = GetExtendedKeyCode( &(ConInpRec.Event.KeyEvent) ) ) {
		    ch = pCP->LeadChar;
		    chbuf = pCP->SecondChar;
		    break;
		}
	    }
	}


	/*
	 * Restore previous console mode.
	 */
        SetConsoleMode( (HANDLE)_coninpfh, oldstate );

	return ch;
}


/*
 * getche is just getch followed by a putch if no error occurred
 */

#ifdef	MTHREAD
int _CRTAPI1 _getche_lk (
#else
int _CRTAPI1 _getche (
#endif
	void
	)
{
	int ch; 	      	/* character read */

	ch = _getch_lk();     	/* read character */
	if (ch != EOF) {
		if (_putch_lk(ch) != EOF) {
			return ch;	/* if no error, return char */
		}
	}	
	return EOF;			/* get or put failed, return EOF */
}


/***
*int _kbhit() - return flag if a keystroke is already waiting to be read
*
*Purpose:
*	If the "_ungetch()" push-back buffer is not empty (empty==-1) Then
*	    Return TRUE
*	Otherwise get the Keyboard Status (via DOSQUERYFHSTATE)
*	No _ext_code buffer is required (unlike the DOS & 16 bit OS/2 world,)
*	since OS/2 buffers the extended code for us.
*
*Entry:
*	None, tests console.
*
*Exit:
*	     returns 0 if no key waiting
*		 = !0 if key waiting
*
*Exceptions:
*
*******************************************************************************/

#ifdef	MTHREAD

int _CRTAPI1 _kbhit_lk(void);

int _CRTAPI1 _kbhit (
	void
	)
{
	int retval;

	_mlock(_CONIO_LOCK);		/* secure the console lock */
	retval = _kbhit_lk();		/* determine if a key is waiting */
	_munlock(_CONIO_LOCK);		/* release the console lock */

	return retval;
}

int _CRTAPI1 _kbhit_lk (

#else

int _CRTAPI1 _kbhit (

#endif
	void
	)
{
	void *pblk;
	PINPUT_RECORD pIRBuf;
	DWORD NumPending;
	DWORD NumPeeked;

	/*
	 * if a character has been pushed back, return TRUE
	 */
	if ( chbuf != -1 )
	    return TRUE;

	/*
	 * Peek all pending console events
	 */
	if ( (_coninpfh == -1) ||

	     !GetNumberOfConsoleInputEvents((HANDLE)_coninpfh, &NumPending) ||

	     ((pblk = malloc( NumPending * sizeof(INPUT_RECORD) )) == NULL) )
	{
	    return FALSE;
	}

	/*
	 * Keep pblk unmodified, for use in a later call to free()
	 */
	pIRBuf = (PINPUT_RECORD)pblk;

	if ( PeekConsoleInput( (HANDLE)_coninpfh,
			       pIRBuf,
			       NumPending,
			       &NumPeeked ) &&

	     (NumPeeked != 0L) &&

	     (NumPeeked <= NumPending) )
	{

	    /*
	     * Scan all of the peeked events to determine if any is a key event
	     * which should be recognized.
	     */
	    for ( ; NumPeeked > 0 ; NumPeeked--, pIRBuf++ ) {

		if ( (pIRBuf->EventType == KEY_EVENT) &&

		     (pIRBuf->Event.KeyEvent.bKeyDown) &&

		     ( pIRBuf->Event.KeyEvent.uChar.AsciiChar ||
		       GetExtendedKeyCode( &(pIRBuf->Event.KeyEvent) ) ) )
		{
		    /*
		     * Key event corresponding to an ASCII character or an
		     * extended code. In either case, success!
		     */
		    free(pblk);
		    return TRUE;
		}
	    }
	}

	free(pblk);
	return FALSE;
}


/***
*int _ungetch(c) - push back one character for "_getch()" or "_getche()"
*
*Purpose:
*	If the Push-back buffer "chbuf" is -1 Then
*	    Set "chbuf" to the argument and return the argument
*	Else
*	    Return EOF to indicate an error
*
*Entry:
*	int c - Character to be pushed back
*
*Exit:
*	If successful
*	    returns character that was pushed back
*	Else if error
*	    returns EOF
*
*Exceptions:
*
*******************************************************************************/

#ifdef	MTHREAD

int _CRTAPI1 _ungetch (
	int c
	)
{
	int retval;

	_mlock(_CONIO_LOCK);		/* lock the console */
	retval = _ungetch_lk(c);	/* pushback character */
	_munlock(_CONIO_LOCK);		/* unlock the console */

	return retval;
}
int _CRTAPI1 _ungetch_lk (

#else

int _CRTAPI1 _ungetch (

#endif
	int c
	)
{
	/*
	 * Fail if the char is EOF or the pushback buffer is non-empty
	 */
	if ( (c == EOF) || (chbuf != EOF) )
	    return EOF;

	chbuf = (c & 0xFF);
	return chbuf;
}




/***
* static CharPair * GetExtendedKeyCode(pKE) - return extended code (if any)
*	for key event.
*
*Purpose:
*	Core function for _getch (and getche) and essential to _kbhit. This
*	is the function that determines whether or not a key event NOT
*	accompanied by an ASCII character has an extended code and returns
*	that code.
*
*Entry:
*	None, tests console.
*
*Exit:
*	if successful, returns a pointer to a CharPair value holding the lead
*	and second characters of the extended code.
*
*	if unsuccesful, returns NULL
*
*Exceptions:
*
*******************************************************************************/


static CharPair * _CRTAPI3 GetExtendedKeyCode (
	KEY_EVENT_RECORD *pKE
	)
{
	DWORD CKS;		/* hold dwControlKeyState value */
	CharPair *pCP;		/* pointer to CharPair containing extended
				   code */
	int i;

	// printf("pKE->wVirtualScanCode  = %d\n", (int) (pKE->wVirtualScanCode) );
	// printf("pKE->dwControlKeyState = %lx\n\n", pKE->dwControlKeyState);

	if ( (CKS = pKE->dwControlKeyState) & ENHANCED_KEY ) {

	    /*
	     * Find the appropriate entry in EnhancedKeys[]
	     */
	    for ( pCP = NULL, i = 0 ; i < NUM_EKA_ELTS ; i++ ) {

		if ( EnhancedKeys[i].ScanCode == pKE->wVirtualScanCode ) {

		    if ( CKS & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED) )

			pCP = &(EnhancedKeys[i].AltChars);

		    else if ( CKS & (LEFT_CTRL_PRESSED | LEFT_CTRL_PRESSED) )

			pCP = &(EnhancedKeys[i].CtrlChars);

		    else if ( CKS & SHIFT_PRESSED)

			pCP = &(EnhancedKeys[i].ShiftChars);

		    else

			pCP = &(EnhancedKeys[i].RegChars);

		    break;

		}
	    }

	}

	else {

	    /*
	     * Regular key or a keyboard event which shouldn't be recognized.
	     * Determine which by getting the proper field of the proper
	     * entry in NormalKeys[], and examining the extended code.
	     */
	    if ( CKS & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED) )

		pCP = &(NormalKeys[pKE->wVirtualScanCode].AltChars);

	    else if ( CKS & (LEFT_CTRL_PRESSED | LEFT_CTRL_PRESSED) )

		pCP = &(NormalKeys[pKE->wVirtualScanCode].CtrlChars);

	    else if ( CKS & SHIFT_PRESSED)

		pCP = &(NormalKeys[pKE->wVirtualScanCode].ShiftChars);

	    else

		pCP = &(NormalKeys[pKE->wVirtualScanCode].RegChars);

	    if ( ((pCP->LeadChar != 0) && (pCP->LeadChar != 224)) ||
		 (pCP->SecondChar == 0) )
		/*
		 * Must be a keyboard event which should not be recognized
		 * (e.g., shift key was pressed)
		 */
		pCP = NULL;

	}

	return(pCP);
}