getch.cpp File Reference

#include <conio.h>
#include <corecrt_internal_lowio.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>

Include dependency graph for getch.cpp:

Go to the source code of this file.

Classes
struct	anonymous_namespace{getch.cpp}::CharPair
struct	anonymous_namespace{getch.cpp}::EnhKeyVals
struct	anonymous_namespace{getch.cpp}::NormKeyVals

Namespaces
namespace	anonymous_namespace{getch.cpp}

Macros
#define	NUM_EKA_ELTS   (sizeof(EnhancedKeys) / sizeof(EnhKeyVals))

Functions
static bool	is_getch_pushback_buffer_full ()
static void	add_to_getch_pushback_buffer (int const c)
static int	peek_next_getch_pushback_buffer ()
static int	get_next_getch_pushback_buffer ()
CharPair const *__cdecl	_getextendedkeycode (KEY_EVENT_RECORD *)
int __cdecl	_kbhit_nolock ()
int __cdecl	_getch ()
int __cdecl	_getche ()
int __cdecl	_getch_nolock ()
int __cdecl	_getche_nolock ()
int __cdecl	_kbhit ()
int __cdecl	_ungetch (int const c)
int __cdecl	_ungetch_nolock (int const c)

Variables
static EnhKeyVals const	EnhancedKeys []
static NormKeyVals const	NormalKeys []
size_t const	getch_pushback_buffer_capacity = 3
static int	getch_pushback_buffer [getch_pushback_buffer_capacity]
static int	getch_pushback_buffer_index = 0
static int	getch_pushback_buffer_current_size = 0
intptr_t	__dcrt_lowio_console_input_handle

Macro Definition Documentation

NUM_EKA_ELTS

#define NUM_EKA_ELTS   (sizeof(EnhancedKeys) / sizeof(EnhKeyVals))

Definition at line 63 of file getch.cpp.

Function Documentation

_getch()

int __cdecl _getch

(

void

)

Definition at line 245 of file getch.cpp.

{
    __acrt_lock(__acrt_conio_lock);
    int result = 0;
    __try
    {
        result = _getch_nolock();
    }
    __finally
    {
        __acrt_unlock(__acrt_conio_lock);
    }
    __endtry
    return result;
}

Referenced by _cgets(), _getche(), _tmain(), abort(), DumpFont(), GetPass(), gl_getc(), gl_getcx(), gl_getpass(), main(), MainUsage(), PrintHelp(), ShowAppList(), TestEventsGeneration(), Wait(), and wmain().

_getch_nolock()

int __cdecl _getch_nolock

(

void

)

Definition at line 277 of file getch.cpp.

{
    // Check the pushback buffer for a character.  If one is present, return it:
    int const pushback = get_next_getch_pushback_buffer();
    if (pushback != EOF)
    {
        return pushback;
    }
 
    if (__dcrt_lowio_ensure_console_input_initialized() == FALSE) {
        return EOF;
    }
 
    // Switch console to raw mode:
    DWORD old_console_mode;
    __dcrt_get_input_console_mode(&old_console_mode);
    __dcrt_set_input_console_mode(0);
 
    int result = 0;
 
    __try
    {
        for ( ; ; )
        {
            // Get a console input event:
            INPUT_RECORD input_record;
            DWORD num_read;
 
            if (__dcrt_read_console_input(&input_record, 1, &num_read) == FALSE || num_read == 0)
            {
                result = EOF;
                __leave;
            }
 
            // Look for, and decipher, key events.
            if (input_record.EventType == KEY_EVENT && input_record.Event.KeyEvent.bKeyDown)
            {
                // Simple case:  if UnicodeChar is non-zero, we can convert it to char and return it.
                wchar_t const c = input_record.Event.KeyEvent.uChar.UnicodeChar;
                if (c != 0)
                {
                    wchar_t const c_buffer[2] = {c, L'\0'};
                    char mb_chars[4];
 
                    size_t const amount_written = __acrt_wcs_to_mbs_cp_array(
                        c_buffer,
                        mb_chars,
                        GetConsoleCP()
                        );
 
                    // Mask with 0xFF to just get lowest byte
                    if (amount_written >= 1) {
                        result = mb_chars[0] & 0xFF;
                    }
 
                    if (amount_written >= 2) {
                        for (size_t i = 1; i < amount_written; ++i) {
                            add_to_getch_pushback_buffer(mb_chars[i] & 0xFF);
                        }
                    }
                    __leave;
                }
 
                // Hard case:  either it is an extended code or an event which
                // should not be recognized.  Let _getextendedkeycode do the work:
                CharPair const* const cp = _getextendedkeycode(&input_record.Event.KeyEvent);
                if (cp != nullptr)
                {
                    // Mask with 0xFF to just get lowest byte
                    add_to_getch_pushback_buffer(cp->SecondChar & 0xFF);
                    result = cp->LeadChar & 0xFF;
                    __leave;
                }
            }
        }
    }
    __finally
    {
        // Restore the previous console mode:
        __dcrt_set_input_console_mode(old_console_mode);
    }
    __endtry
    return result;
}

Referenced by _getch(), and _getche_nolock().

_getche()

int __cdecl _getche

(

void

)

Definition at line 261 of file getch.cpp.

{
    __acrt_lock(__acrt_conio_lock);
    int result = 0;
    __try
    {
        result = _getche_nolock();
    }
    __finally
    {
        __acrt_unlock(__acrt_conio_lock);
    }
    __endtry
    return result;
}

_getche_nolock()

int __cdecl _getche_nolock

(

void

)

Definition at line 364 of file getch.cpp.

{
    // Check the pushback buffer for a character.  If one is present, return
    // it without echoing:
    int const pushback = get_next_getch_pushback_buffer();
    if (pushback != EOF)
    {
        return pushback;
    }
 
    // Otherwise, read the next character from the console and echo it:
    int const c = _getch_nolock();
    if (c == EOF)
        return EOF;
 
    if (_putch_nolock(c) == EOF)
        return EOF;
 
    return c;
}

Referenced by _getche().

_getextendedkeycode()

CharPair const *__cdecl _getextendedkeycode

(

KEY_EVENT_RECORD *

pKE

)

Definition at line 506 of file getch.cpp.

{
    DWORD const CKS = pKE->dwControlKeyState;
 
    if (CKS & ENHANCED_KEY)
    {
        // Find the appropriate entry in EnhancedKeys[]:
        for (int i = 0 ; i < NUM_EKA_ELTS; ++i)
        {
            if (EnhancedKeys[i].ScanCode != pKE->wVirtualScanCode)
            {
                continue;
            }
 
            // We found a match!  Determine which pair to return:
            if (CKS & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED))
            {
                return &EnhancedKeys[i].AltChars;
            }
            else if (CKS & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
            {
                return &EnhancedKeys[i].CtrlChars;
            }
            else if (CKS & SHIFT_PRESSED)
            {
                return &EnhancedKeys[i].ShiftChars;
            }
            else
            {
                return &EnhancedKeys[i].RegChars;
            }
        }
 
        return nullptr;
    }
    else
    {
        // Regular key or 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.
        CharPair const* pCP;
 
        if (CKS & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED))
        {
            pCP = &NormalKeys[pKE->wVirtualScanCode].AltChars;
        }
        else if (CKS & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
        {
            pCP = &NormalKeys[pKE->wVirtualScanCode].CtrlChars;
        }
        else if (CKS & SHIFT_PRESSED)
        {
            pCP = &NormalKeys[pKE->wVirtualScanCode].ShiftChars;
        }
        else
        {
            pCP = &NormalKeys[pKE->wVirtualScanCode].RegChars;
        }
 
        // Make sure it wasn't a keyboard event which should not be recognized
        // (e.g. the shift key was pressed):
        if ((pCP->LeadChar != 0 && pCP->LeadChar != 224) || pCP->SecondChar == 0)
        {
            return nullptr;
        }
 
        return pCP;
    }
}

Referenced by _getch_nolock(), _getwch_nolock(), and _kbhit_nolock().

_kbhit()

int __cdecl _kbhit

(

void

)

Definition at line 388 of file getch.cpp.

{
    __acrt_lock(__acrt_conio_lock);
    int result = 0;
    __try
    {
        result = _kbhit_nolock();
    }
    __finally
    {
        __acrt_unlock(__acrt_conio_lock);
    }
    __endtry
    return result;
}

Referenced by gl_getcx(), and main().

_kbhit_nolock()

int __cdecl _kbhit_nolock

(

)

Definition at line 406 of file getch.cpp.

{
    // If a character has been pushed back, return TRUE:
    if (peek_next_getch_pushback_buffer() != EOF) {
        return TRUE;
    }
 
    if (__dcrt_lowio_ensure_console_input_initialized() == FALSE) {
        return FALSE;
    }
 
    // Peek at all pending console events:
    DWORD num_pending;
    if (__dcrt_get_number_of_console_input_events(&num_pending) == FALSE) {
        return FALSE;
    }
 
    if (num_pending == 0) {
        return FALSE;
    }
 
    __crt_scoped_stack_ptr<INPUT_RECORD> const input_buffer(_malloca_crt_t(INPUT_RECORD, num_pending));
    if (input_buffer.get() == nullptr) {
        return FALSE;
    }
 
    DWORD num_peeked;
    // AsciiChar is not read, so using the narrow Win32 API is permitted.
    if (__dcrt_peek_console_input_a(input_buffer.get(), num_pending, &num_peeked) == FALSE) {
        return FALSE;
    }
 
    if (num_peeked == 0 || num_peeked > num_pending) {
        return FALSE;
    }
 
    // Scan all of the peeked events to determine if any is a key event
    // that should be recognized:
    for (INPUT_RECORD* p = input_buffer.get(); num_peeked > 0; --num_peeked, ++p)
    {
        if (p->EventType != KEY_EVENT)
            continue;
 
        if (!p->Event.KeyEvent.bKeyDown)
            continue;
 
        if (p->Event.KeyEvent.uChar.AsciiChar == 0 &&
            _getextendedkeycode(&p->Event.KeyEvent) == nullptr)
            continue;
 
        return TRUE;
    }
 
    return FALSE;
}

Referenced by _kbhit().

_ungetch()

int __cdecl _ungetch

(

int const

c

)

Definition at line 467 of file getch.cpp.

{
    __acrt_lock(__acrt_conio_lock);
    int result = 0;
    __try
    {
        result = _ungetch_nolock(c);
    }
    __finally
    {
        __acrt_unlock(__acrt_conio_lock);
    }
    __endtry
    return result;
}

Referenced by _cgets().

_ungetch_nolock()

int __cdecl _ungetch_nolock

(

int const

c

)

Definition at line 485 of file getch.cpp.

{
    // Fail if the character is EOF or the pusback buffer is nonempty:
    if (c == EOF || is_getch_pushback_buffer_full()) {
        return EOF;
    }
 
    add_to_getch_pushback_buffer(c);
    return c;
}

Referenced by _ungetch().

add_to_getch_pushback_buffer()

static void add_to_getch_pushback_buffer ( int const  c )

static

Definition at line 201 of file getch.cpp.

{
    _ASSERTE(!is_getch_pushback_buffer_full());
    getch_pushback_buffer[getch_pushback_buffer_current_size++] = c;
}

Referenced by _getch_nolock(), and _ungetch_nolock().

get_next_getch_pushback_buffer()

static int get_next_getch_pushback_buffer ( )

static

Definition at line 216 of file getch.cpp.

{
    if (getch_pushback_buffer_current_size == 0) {
        return EOF;
    }
 
    int const ret_val = getch_pushback_buffer[getch_pushback_buffer_index++];
 
    if (getch_pushback_buffer_index == getch_pushback_buffer_current_size) {
        getch_pushback_buffer_index = 0;
        getch_pushback_buffer_current_size = 0;
    }
 
    return ret_val;
}

Referenced by _getch_nolock(), and _getche_nolock().

is_getch_pushback_buffer_full()

static bool is_getch_pushback_buffer_full ( )

static

Definition at line 196 of file getch.cpp.

{
    return getch_pushback_buffer_current_size >= getch_pushback_buffer_capacity;
}

Referenced by _ungetch_nolock(), and add_to_getch_pushback_buffer().

peek_next_getch_pushback_buffer()

static int peek_next_getch_pushback_buffer ( )

static

Definition at line 207 of file getch.cpp.

{
    if (getch_pushback_buffer_current_size == 0) {
        return EOF;
    }
 
    return getch_pushback_buffer[getch_pushback_buffer_index];
}

Referenced by _kbhit_nolock().

Variable Documentation

__dcrt_lowio_console_input_handle

intptr_t __dcrt_lowio_console_input_handle

Definition at line 232 of file getch.cpp.

EnhancedKeys

EnhKeyVals const EnhancedKeys[]

static

Initial value:

=
{
    { 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 } }
}

Definition at line 46 of file getch.cpp.

Referenced by _getextendedkeycode().

getch_pushback_buffer

int getch_pushback_buffer[getch_pushback_buffer_capacity]

static

Definition at line 192 of file getch.cpp.

Referenced by add_to_getch_pushback_buffer(), get_next_getch_pushback_buffer(), and peek_next_getch_pushback_buffer().

getch_pushback_buffer_capacity

size_t const getch_pushback_buffer_capacity = 3

Definition at line 190 of file getch.cpp.

Referenced by is_getch_pushback_buffer_full().

getch_pushback_buffer_current_size

int getch_pushback_buffer_current_size = 0

static

Definition at line 194 of file getch.cpp.

Referenced by add_to_getch_pushback_buffer(), get_next_getch_pushback_buffer(), is_getch_pushback_buffer_full(), and peek_next_getch_pushback_buffer().

getch_pushback_buffer_index

int getch_pushback_buffer_index = 0

static

Definition at line 193 of file getch.cpp.

Referenced by get_next_getch_pushback_buffer(), and peek_next_getch_pushback_buffer().

NormalKeys

NormKeyVals const NormalKeys[]

static

Definition at line 69 of file getch.cpp.

Referenced by _getextendedkeycode().