getwch.cpp File Reference

#include <conio.h>
#include <corecrt_internal_lowio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>

Include dependency graph for getwch.cpp:

Go to the source code of this file.

Classes
struct	anonymous_namespace{getwch.cpp}::CharPair

Namespaces
namespace	anonymous_namespace{getwch.cpp}

Functions
CharPair const *__cdecl	_getextendedkeycode (KEY_EVENT_RECORD *)
wint_t __cdecl	_getwch ()
wint_t __cdecl	_getwche ()
wint_t __cdecl	_getwch_nolock ()
wint_t __cdecl	_getwche_nolock ()
wint_t __cdecl	_ungetwch (wint_t const c)
wint_t __cdecl	_ungetwch_nolock (wint_t const c)

Variables
static wint_t	wchbuf = WEOF
intptr_t	__dcrt_lowio_console_input_handle

Function Documentation

_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().

_getwch()

wint_t __cdecl _getwch

(

void

)

Definition at line 42 of file getwch.cpp.

{
    __acrt_lock(__acrt_conio_lock);
    wint_t result = 0;
    __try
    {
        result = _getwch_nolock();
    }
    __finally
    {
        __acrt_unlock(__acrt_conio_lock);
    }
    __endtry
    return result;
}

_getwch_nolock()

wint_t __cdecl _getwch_nolock

(

void

)

Definition at line 77 of file getwch.cpp.

{
    // First check the pushback buffer for a character.  If it has one, return
    // it without echoing and reset the buffer:
    if (wchbuf != WEOF)
    {
        wchar_t const buffered_wchar = static_cast<wchar_t>(wchbuf & 0xFFFF);
        wchbuf = WEOF;
        return buffered_wchar;
    }
 
    // The console input handle is created the first time that _getwch(),
    // _cgetws(), or _kbhit() is called:
    if (__dcrt_lowio_ensure_console_input_initialized() == FALSE)
        return WEOF;
 
    // Switch to raw mode (no line input, no echo input):
    DWORD old_console_mode;
    __dcrt_get_input_console_mode(&old_console_mode);
    __dcrt_set_input_console_mode(0);
    wint_t 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)
            {
                result = WEOF;
                __leave;
            }
 
            if (num_read == 0)
            {
                result = WEOF;
                __leave;
            }
 
            // Look for, and decipher, key events.
            if (input_record.EventType == KEY_EVENT && input_record.Event.KeyEvent.bKeyDown)
            {
                // Easy case:  if UnicodeChar is non-zero, we can just return it:
                wchar_t const c = static_cast<wchar_t>(input_record.Event.KeyEvent.uChar.UnicodeChar);
                if (c != 0)
                {
                    result = c;
                    __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)
                {
                    wchbuf = cp->SecondChar;
                    result = cp->LeadChar;
                    __leave;
                }
            }
        }
    }
    __finally
    {
        // Restore the previous console mode:
        __dcrt_set_input_console_mode(old_console_mode);
    }
    __endtry
    return result;
}

Referenced by _getwch(), and _getwche_nolock().

_getwche()

wint_t __cdecl _getwche

(

void

)

Definition at line 59 of file getwch.cpp.

{
    __acrt_lock(__acrt_conio_lock);
    wint_t result = 0;
    __try
    {
        result = _getwche_nolock();
    }
    __finally
    {
        __acrt_unlock(__acrt_conio_lock);
    }
    __endtry
    return result;
}

_getwche_nolock()

wint_t __cdecl _getwche_nolock

(

void

)

Definition at line 151 of file getwch.cpp.

{
    // First check the pushback buffer for a character.  If it has one, return
    // it without echoing and reset the buffer:
    if (wchbuf != WEOF)
    {
        wchar_t const buffered_wchar = static_cast<wchar_t>(wchbuf & 0xFFFF);
        wchbuf = WEOF;
        return buffered_wchar;
    }
 
    // Othwrwise, read the character, echo it, and return it.  If anything fails,
    // we immediately return WEOF.
    wchar_t const gotten_wchar = _getwch_nolock();
    if (gotten_wchar == WEOF)
        return WEOF;
 
    if (_putwch_nolock(gotten_wchar) == WEOF)
        return WEOF;
 
    return gotten_wchar;
}

Referenced by _getwche().

_ungetwch()

wint_t __cdecl _ungetwch

(

wint_t const

c

)

Definition at line 179 of file getwch.cpp.

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

_ungetwch_nolock()

wint_t __cdecl _ungetwch_nolock

(

wint_t const

c

)

Definition at line 197 of file getwch.cpp.

{
    // Fail if the char is EOF or the pushback buffer is non-empty:
    if (c == WEOF || wchbuf != WEOF)
        return static_cast<wint_t>(EOF);
 
    wchbuf = (c & 0xFF);
    return wchbuf;
}

Referenced by _ungetwch().

Variable Documentation

__dcrt_lowio_console_input_handle

intptr_t __dcrt_lowio_console_input_handle

Definition at line 30 of file getwch.cpp.

wchbuf

wint_t wchbuf = WEOF

static

Definition at line 28 of file getwch.cpp.

Referenced by _getwch_nolock(), _getwche_nolock(), and _ungetwch_nolock().